brown121407 has quit [Remote host closed the connection]
andreas303 has quit [Remote host closed the connection]
sarna has joined #ocaml
spew has quit [Quit: Connection closed for inactivity]
andreas303 has joined #ocaml
olle has joined #ocaml
mbuf has quit [Ping timeout: 240 seconds]
mbuf has joined #ocaml
mbuf has quit [Ping timeout: 265 seconds]
vicfred has quit [Quit: Leaving]
malc_ has joined #ocaml
dckc has quit [Ping timeout: 256 seconds]
osa1 has quit [Read error: Connection reset by peer]
osa1 has joined #ocaml
dckc has joined #ocaml
<d_bot>
<Christophe> Should this server be at least a Community server, or even a Verified server, and make the #announcements channel into a "real" news channel (in the Discord) like ReasonML did ? We could follow their announcement channel here, and they could follow this one
madroach has joined #ocaml
_whitelogger has joined #ocaml
<d_bot>
<Et7f3> We are not enough last time
<d_bot>
<Et7f3> But from history of message reasonml was certified very quickly at the start
brown121407 has joined #ocaml
brown121407 has quit [Read error: Connection reset by peer]
tianon has quit [Ping timeout: 260 seconds]
brown121407 has joined #ocaml
brown121407 has quit [Remote host closed the connection]
tianon has joined #ocaml
mfp has joined #ocaml
Haudegen has quit [Quit: Bin weg.]
laokz has joined #ocaml
raver has quit [Quit: Gateway shutdown]
raver has joined #ocaml
reynir has quit [Ping timeout: 256 seconds]
reynir has joined #ocaml
malc_ has quit [Ping timeout: 272 seconds]
worc3131 has joined #ocaml
osa1_ has joined #ocaml
osa1_ has quit [Client Quit]
nullcone has quit [Quit: Connection closed for inactivity]
Haudegen has joined #ocaml
laokz has quit [Ping timeout: 240 seconds]
nicoo has quit [Ping timeout: 240 seconds]
webshinra has quit [Remote host closed the connection]
<d_bot>
<Champiz Cooking> Merlin doesn't work. Is it because it doesn't use ocamlc?
<d_bot>
<Champiz Cooking> Merlin doesn't work. Is it because it doesn't use ocamlc, or because I have misconfigured it? (edited)
narimiran has quit [Ping timeout: 256 seconds]
<d_bot>
<Champiz Cooking> Merlin doesn't work (or rather, it does, but gives me a syntax error on `effect _ : ` declarations). Is it because it doesn't use ocamlc, or because I have misconfigured it? (edited)
<d_bot>
<Et7f3> merlin works only on mono-core
<d_bot>
<octachron> Merlin is very coupled to the version of the compiler. I don't know if vanilla merlin can work with OCaml multicore
dckc has quit [Ping timeout: 244 seconds]
dckc has joined #ocaml
waleee-cl has joined #ocaml
osa1 has joined #ocaml
laokz has quit [Quit: Leaving]
malc_ has joined #ocaml
Haudegen has quit [Quit: Bin weg.]
sarna has quit [Quit: Connection closed]
<sadiq>
Champiz Cooking: you want to use the no-effect branch
malc_ has left #ocaml ["ERC (IRC client for Emacs 28.0.50)"]
<d_bot>
<sadiq> this branch mostly tracks the parallel_minor_gc one but removes the effect syntax
<d_bot>
<sadiq> I _think_ that should make it compatible with merlin and ppx
<companion_cube>
octachron: your comment on the difficulty of reporting on the compiler's core maintainers meetings intruigued me
<companion_cube>
it'd be sweet to have more communication around that
<d_bot>
<Champiz Cooking> @sadiq But I do want to declare effects? I am not sure how using the `no-effect-syntax` helps?
<d_bot>
<sadiq> oh, if you want to declare effects then the syntax is no longer compatible with 4.10.0
<d_bot>
<sadiq> the no-effect-syntax is mainly aimed at people who wanted to experiment with domains-only parallelism on existing codebases
<d_bot>
<Anurag> the no-effect-syntax variant has been helpful when trying the multicore version on existing projects with ppx dependencies
<d_bot>
<Et7f3> multicore has a new ppx node also
<d_bot>
<Et7f3> multicore has a new parsetree node also (edited)
<d_bot>
<Drup> @darrenldl What about making next an actual operator in the language ? Also, I think you need to distinguish between sets and ranges, which are not the same
<d_bot>
<Drup> (in analysis terms, ranges are continuous, sets are finites)
<theblatte>
oh no Drup is on the other side of the discord bridge now
<d_bot>
<darrenldl> that is true - daypack only works at second resolution, so i never put too much thought into making that divide clear
<d_bot>
<Drup> doesn't matter what kind of resolution daypack works at, the semantic is not the same. Consider executing some service: executing at each second from A to B is not the same from time A to time B.
<d_bot>
<Et7f3> oh sweet this will allow to match on integer range ?
<d_bot>
<Drup> doesn't matter what kind of resolution daypack works at, the semantic is not the same. Consider executing some service: executing at each second from A to B is not the same as executing from time A to time B. (edited)
<d_bot>
<Drup> theblatte: I go to the side where my interlocutor is ...
<d_bot>
<darrenldl> okay yep fair...
<d_bot>
<Drup> @Et7f3 We are talking about daypack's time expressions, not pattern matches 🙂
<Drup>
and it highlights me on IRC every time I speak on discords, this is just fab. I think I'll end up just not talking on this chan anymore, this bridge is just a pain in the butt.
<d_bot>
<darrenldl> what would be the best solution you reckon? redefine time expressions so there are only ever ranges, and there are no longer operators that pretend to be set operators? or support both sets and ranges explicitly, with the appropriate distinction?
<d_bot>
<parataxis> how do you get a backtrace from an exn in an lwt.catch handler?
<d_bot>
<parataxis> the version of opium currently in development uses some module called Nifty to do it but I don't see any reference to that anywhere else
<d_bot>
<Drup> @darrenldl Well, ideally, I would say that the semantic of a time expression is a set of non-overlaping intervals.
<d_bot>
<Drup> (a time point being a trivial interval)
<d_bot>
<Drup> Then, you get out the usual interval arithmetics, yada, yada
<d_bot>
<Drup> your issue is that you have infinite sets, which makes things slightly tricker, of course
<d_bot>
<Drup> your issue is that you have infinite sets, which makes things slightly trickier, of course (edited)
<d_bot>
<darrenldl> > Well, ideally, I would say that the semantic of a time expression is a set of non-overlaping intervals.
<d_bot>
<darrenldl> right now that would be the normal form of a time expression
<d_bot>
<Drup> yes
<d_bot>
<Drup> (from a PL perspective, that would the denotation semantics :3)
brown121407 has joined #ocaml
<d_bot>
<Drup> (from a PL perspective, that would the denotational semantics :3) (edited)
<d_bot>
<darrenldl> so concretely of what i should do: stop calling them set operators, and define operators (|| and &&) explicitly in terms of ranges?
<d_bot>
<Drup> No, && and || are still set operators ... over set of ranges.
<d_bot>
<parataxis> Printexc.get_backtrace in the exception handler in a try%lwt doesn't seem to do anything useful either
<d_bot>
<parataxis> Raised at file "string.ml", line 115, characters 19-34
<d_bot>
<parataxis> Called from file "sexp.ml", line 112, characters 13-47
<d_bot>
<parataxis> tells me nothing
<d_bot>
<darrenldl> > over set of ranges
<d_bot>
<darrenldl> ...oh...oh right...yeah...
<d_bot>
<Drup> @darrenldl To make things clearer; your current semantic object is a `Timestamp.t Seq.t`, it should be a `Range.t Seq.t`. That's about it.
<d_bot>
<Drup> (well, no, everything is complicated when talking about infinite sets and time, but ...)
brown121407 has quit [Remote host closed the connection]
<d_bot>
<darrenldl> Okay I think I get what you mean...now i need to try rewording things correctly
<d_bot>
<darrenldl>
<d_bot>
<darrenldl> Thanks!
osa1 has quit [Quit: osa1]
osa1 has joined #ocaml
<d_bot>
<darrenldl> @Drup somewhat in relation for "next": should intervals that are disjoint normlise to a single interval if the single interval can represent the same set of values? (hope i'm using the words correctly this time)
<d_bot>
<hcarty> @parataxis Ah, that's unfortunate. From what I recall, `*%lwt` is the simplest path to getting backtraces within lwt. Maybe the ppx is missing appropriate translation to support that in the `try%lwt` case? You could try asking in the `lwt` channel here on discord or raise an issue in against lwt itself
<d_bot>
<Drup> @darrenldl That's why I said "non-overlaping". If they overlap, your merge them.
<d_bot>
<Drup> @darrenldl That's why I said "non-overlaping". If 2 intervals overlap, your merge them. (edited)
<d_bot>
<darrenldl> so if they don't overlap, then they should never merge
<d_bot>
<Drup> Well, that would change the semantics
<d_bot>
<Drup> we don't want that here 🙂
<d_bot>
<darrenldl> okay...i'll have to rethink the search function - returning individual seconds as trivial intervals for an entire year is ridiculously slow in the current implementation...
<d_bot>
<Drup> no kidding.
olle has quit [Ping timeout: 260 seconds]
<d_bot>
<Drup> @darrenldl This also means you will be able to add new queries that I don't think you could express so far, like "please find the next 2h slot in the intersection of these time schedules"
<d_bot>
<Drup> Also, a `not` operator.
<companion_cube>
are y'all talking about that time tool?
<d_bot>
<darrenldl> yep
landonf has quit [Excess Flood]
landonf has joined #ocaml
<d_bot>
<darrenldl> @Drup would `not` return one or more (large) intervals, or all seconds not inside the original interval in (many) trivial intervals?
<d_bot>
<Drup> It's the complement
<d_bot>
<Drup> So, if you have a sequence of intervals, it's very easy to define directly
<d_bot>
<darrenldl> so there would be no difference between `not [0, 1, 2, 3]` and `not [0, 4)`?
<companion_cube>
you can even replace the `Seq.t` with a tree
<companion_cube>
for faster lookups
<d_bot>
<Drup> @companion_cube it's not finite :3
<companion_cube>
why not?
<companion_cube>
ah, repetitions?
<d_bot>
<Drup> because time is INIFITE \O/
<d_bot>
<darrenldl> (right now not is defined as relative complement to search range)
<companion_cube>
yeah but if you have a finite number of ranges you're good
<companion_cube>
just allow for open-ended ranges
<d_bot>
<Drup> "every day at 2pm"
<companion_cube>
odds are you can do some kind of automaton there :)
<companion_cube>
but ok
<companion_cube>
repetitions
<d_bot>
<Drup> @darrenldl Actually, there is probably no difference between [0,1,2,3] and [0,4[
<d_bot>
<darrenldl> @companion_cube meaningfully it would be finite, in practice i just want the memory usage to not blow up when i try to match through say 100 years of time, so that's mainly why I did things in Seq.t
<d_bot>
<Drup> (but I don't think you ever get [0,1,2,3] in practice, it would be meain pointwise describe of each seconds, that's weirdly specific)
<d_bot>
<Drup> @companion_cube Actually, I hink I've heard about time automatons ... and this whole discussion reminds me of what we did for regular expressions ...
nullcone has joined #ocaml
<d_bot>
<darrenldl> > Actually, there is probably no difference between [0,1,2,3] and [0,4[
<d_bot>
<darrenldl> so then we allow merging of non-overlapping intervals? or am i misunderstading things again
<d_bot>
<Drup> @darrenldl Well, I mean, is there anything beween 0 and 1 ?
<d_bot>
<Drup> if no, then you can merge, if not, then you can't
<d_bot>
<darrenldl> so [a, b), [b, c) may merge, is what you're saying
<d_bot>
<Drup> that seems logical, yes
<d_bot>
<darrenldl> (where [,) is the exclusive range notation)
<d_bot>
<darrenldl> okay right
<d_bot>
<Drup> It seems to me that your semantic of "second number n" is `[n,n+1)`, right ?
<d_bot>
<darrenldl> > that seems logical, yes
<d_bot>
<darrenldl> okay, that is a big relief (the current search function relies on that assumption, the main significance is that it short circuits pattern matching of an entire year/month/day/hour/minute into an interval directly, this skips generating then merging a lot of trivial intervals)
<d_bot>
<darrenldl> > It seems to me that your semantic of "second number n" is [n,n+1), right ?
<d_bot>
<darrenldl> yes
<octachron>
companion_cube, part of the difficulty is that developer meetings often end up with at most soft agreements on what people might work in the next release cycle.
ransom has joined #ocaml
Tuplanolla has joined #ocaml
<ollehar>
time is not infinite...
ransom has quit [Ping timeout: 240 seconds]
vicfred has joined #ocaml
ransom has joined #ocaml
<companion_cube>
Drup: yes, it seems automata should be the clean way
<Drup>
companion_cube: depends the kind of query you want to run. An explicit representation might be preferable
ransom has quit [Ping timeout: 264 seconds]
osa1 has quit [Ping timeout: 264 seconds]
ransom has joined #ocaml
borne has quit [Ping timeout: 260 seconds]
aaaaaa has joined #ocaml
ransom has quit [Ping timeout: 260 seconds]
Haudegen has joined #ocaml
osa1 has joined #ocaml
ransom has joined #ocaml
ransom has quit [Client Quit]
ransom has joined #ocaml
bartholin has joined #ocaml
worc3131 has quit [Remote host closed the connection]
nullcone has quit [Quit: Connection closed for inactivity]