troydm has quit [Quit: What is Hope? That all of your wishes and all of your dreams come true? To turn back time because things were not supposed to happen like that (C) Rau Le Creuset]
env__ has joined #ocaml
kleimkuhler has joined #ocaml
troydm has joined #ocaml
env__ has quit [Ping timeout: 260 seconds]
BitPuffin has quit [Remote host closed the connection]
<benzrf>
ocaml doesnt have multi-clause function definitions like haskell? (e.g., "foo [] = []; foo (x:xs) = x + 1 : foo xs;" where single colon is cons)
<benzrf>
also it seems a little worrying that the type of (=) is a lie
<benzrf>
and doesn't it require some sort of runtime type tagging to be able to notice that something isn't valid to compare?
env__ has quit [Ping timeout: 256 seconds]
kleimkuhler has joined #ocaml
<benzrf>
more questions: is there a reason why "Foo of a * b" means something different from "Foo of (a * b)"? or to put it another way: why not just have the latter be the only thing you can do? what's the advantage of having this notion of "multiple constructor args" even tho it's always gonna look like tuple stuff? idk
<lyxia>
no multi-clause function, just write foo = function | [] -> [] | x :: xs -> (x + 1) :: foo xs
<reynir>
:: is a special constructor like true and false
<lyxia>
let rec*
<reynir>
Foo of 'a * 'b is a variant with two parameters while Foo of ('a * 'b) is a variant of one parameter. IIRC the latter will require one more allocation
<reynir>
you can't write »match Foo (1, '2') with Foo x -> x« with the former definition
<benzrf>
lyxia: oh this 'function' syntax is nice
<benzrf>
reynir: yeh i was wondering why the former exists at all since the latter seems to subsume its functionality
<benzrf>
but the extra allocation makes sense i guess
<reynir>
The * doesn't mean pair type constructor in the former case. It's like Foo a b vs Foo (a, b) in Haskell (IIRC the syntax)
<benzrf>
yeah no i understand
<benzrf>
...i guess when i put it like i just did, i might as well ask the same question about haskell
<benzrf>
:\
<benzrf>
ok ive just encountered mutable fields
<benzrf>
this seems kinda fucked up
<benzrf>
is it basically just sugar for refs
env__ has joined #ocaml
<reynir>
other way around, ref is sugar for a mutable record type 'a ref = { mutable contents : 'a; }
<benzrf>
._.
<reynir>
(well, these days anyway, it might have been different historically; I dunno...)
<benzrf>
god dammit
<benzrf>
is it too much to ask of a language that values be values :{
<reynir>
what do you mean
<benzrf>
well, i'm mostly being facetious
<benzrf>
but i think there's a lot of mental load to be alleviated in not thinking about values as being objects with identities, but just as /values/
<pierpa>
historically, it was the other way around. Mutable record fields were sugar for ref fields. Sometime later they switched.
<reynir>
morning pierpa o/
<lyxia>
I'm not sure that can work without the language being pure, and OCaml clearly made the choice to not be a pure language.
<pierpa>
hey Reynir!
<benzrf>
well, i feel like mutability being only thru refs creates a clear distinction
<benzrf>
type of thing
<benzrf>
i guess it ends up being a matter of splitting hairs
<benzrf>
shrug
<benzrf>
like i'd say C has the property i'm talking about to be entirely honest :v
<benzrf>
a value is a value in C!
<reynir>
what isn't a value in OCaml?
<benzrf>
something with mutable fields
loli1 has joined #ocaml
<reynir>
why do you say it isn't a value?
<benzrf>
er, i mean, i'm not working off of a widespread technical definition, sorry
<benzrf>
but by a "value" i mean, like, a /piece of data/, rather an a /thing with an identity/
<benzrf>
informally speaking
<reynir>
{ contents = 1 } = { contents = 1 } will still work?
pierpa has quit [Quit: Page closed]
<benzrf>
oh hm, refs compare by contents and not by identity?
<reynir>
(==) compares by identity if you should need that
<benzrf>
>Another critical ingredient for parallelism is the concept of a persistent data structure, one for which its associated operations transform, rather than alter, it. A persistent dictionary, for example, has the characteristic that inserting an element results in a new dictionary with an expanded domain; the old dictionary persists, and is still available for further transformation. When calculating the sum
<benzrf>
of 2 and 2, resulting in 4, no one imagines that the 2’s are “used up” in the process! Nor does one worry whether the sum of 1 and 3 is the “same” 4 or a “different” 4! The very question is absurd (or, more precisely, trivial). So why do we worry about whether the result of inserting 2 into dict “uses up” the old dict? And why do we worry about whether inserting 2 into the empty
<benzrf>
dictionary twice results in the “same” dictionary or a “different” one?
<benzrf>
in a language like C or haskell, values do not have "identities", they are just pieces of data
<benzrf>
if you write down the value and then put it back in, it's still the same value
<benzrf>
it's never the case that you've created a "new" thing
<benzrf>
(semantically)
kleimkuhler has quit [Quit: kleimkuhler]
kleimkuhler has joined #ocaml
env__ has quit [Ping timeout: 264 seconds]
<Maxdamantus>
I'd call that data.
* Maxdamantus
doesn't like that meaning of "value"
<Maxdamantus>
A value should just be something you can store in a variable/field or return from a function, etc
<Maxdamantus>
if the language has pointers of some sort that can be passed around like that, those pointers are values.
<Maxdamantus>
FP is about only dealing with data (I'm sure I've heard phrases like "functions as data" somewhere)
<benzrf>
"data" is a good one
<benzrf>
but yeah id thought that MLs went for only having data as values and then you can use refs for mutable logic, not unlike C
<benzrf>
i guess not
pierpal has quit [Quit: Poof]
pierpal has joined #ocaml
env__ has joined #ocaml
env__ has quit [Ping timeout: 260 seconds]
kleimkuhler has quit [Quit: kleimkuhler]
env__ has joined #ocaml
env__ has quit [Ping timeout: 260 seconds]
env__ has joined #ocaml
env__ has quit [Ping timeout: 240 seconds]
kleimkuhler has joined #ocaml
env__ has joined #ocaml
<ELLIOTTCABLE>
o7 all
<ELLIOTTCABLE>
are _opam directories (directory-local switches) still unrelocatable?
env__ has quit [Ping timeout: 256 seconds]
env__ has joined #ocaml
env__ has quit [Ping timeout: 256 seconds]
env__ has joined #ocaml
lopex has quit [Quit: Connection closed for inactivity]
loli has quit [Ping timeout: 256 seconds]
loli1 has quit [Ping timeout: 260 seconds]
env__ has quit [Ping timeout: 240 seconds]
loli has joined #ocaml
loli1 has joined #ocaml
env__ has joined #ocaml
kleimkuhler has quit [Quit: kleimkuhler]
env__ has quit [Ping timeout: 248 seconds]
pierpal has quit [Read error: Connection reset by peer]
env__ has joined #ocaml
<discord>
<rgrinberg> I think so. Note that it's because the compiler itself is unrelocatable
TarVanimelde has joined #ocaml
env__ has quit [Ping timeout: 256 seconds]
pierpal has joined #ocaml
env__ has joined #ocaml
env__ has quit [Ping timeout: 240 seconds]
env__ has joined #ocaml
env__ has quit [Ping timeout: 256 seconds]
env__ has joined #ocaml
env__ has quit [Ping timeout: 248 seconds]
letoh has quit [Ping timeout: 256 seconds]
env__ has joined #ocaml
env__ has quit [Ping timeout: 256 seconds]
env__ has joined #ocaml
env__ has quit [Ping timeout: 240 seconds]
tarptaeya has joined #ocaml
env__ has joined #ocaml
env__ has quit [Ping timeout: 240 seconds]
env__ has joined #ocaml
env__ has quit [Ping timeout: 256 seconds]
zolk3ri has joined #ocaml
env__ has joined #ocaml
nullifidian__ has joined #ocaml
env__ has quit [Ping timeout: 240 seconds]
nullifidian_ has quit [Ping timeout: 256 seconds]
env__ has joined #ocaml
env__ has quit [Ping timeout: 240 seconds]
env__ has joined #ocaml
env__ has quit [Ping timeout: 248 seconds]
env__ has joined #ocaml
TarVanimelde has quit [Quit: TarVanimelde]
env__ has quit [Ping timeout: 264 seconds]
env__ has joined #ocaml
env__ has quit [Ping timeout: 240 seconds]
env__ has joined #ocaml
env__ has quit [Ping timeout: 244 seconds]
loli1 has quit [Ping timeout: 265 seconds]
env__ has joined #ocaml
env__ has quit [Ping timeout: 240 seconds]
env__ has joined #ocaml
argent_smith has joined #ocaml
env__ has quit [Ping timeout: 240 seconds]
<Leonidas>
ELLIOTTCABLE: yes, I think so. It looks like that is the main reason why you just can't symlink switches
<Leonidas>
really wish it could be, then I wouldn't have 4.06.1 installed in 20 switches :(
env__ has joined #ocaml
env__ has quit [Ping timeout: 276 seconds]
gareppa has joined #ocaml
env__ has joined #ocaml
env__ has quit [Ping timeout: 256 seconds]
env__ has joined #ocaml
env__ has quit [Ping timeout: 256 seconds]
env__ has joined #ocaml
BitPuffin has joined #ocaml
env__ has quit [Ping timeout: 260 seconds]
jonas1 has joined #ocaml
jonas1 has quit [Client Quit]
jonas1 has joined #ocaml
jonas1 has quit [Client Quit]
lambda has joined #ocaml
lambda is now known as Guest67896
env__ has joined #ocaml
<discord>
<rgrinberg> esy has a hack to rename copmilers by editing the binaries, but it would be really nice if this just wasn't necessary
<discord>
<rgrinberg> AFAIK, the compiler isn't relocatable so that bytecode binaries know which interpreter to run :/
<discord>
<rgrinberg> doesn't seem like a very strong reason to lose this key feature
<Guest67896>
does anzone knows a good tutorial how to build functors in ocaml
<Leonidas>
rgrinberg: you mean losing relocability or loosing the ability to run bytecode binaries?
env__ has joined #ocaml
<Leonidas>
How is this even implemented? Does the bytecode hardcode the path to the compiler that created them? Relocability does not interfere with this.
env__ has quit [Ping timeout: 255 seconds]
<Drup>
Leonidas: `less $(which ocamlc.byte)` should answer your question ;)
haesbaert has quit [Read error: Connection reset by peer]
env__ has joined #ocaml
lambda has joined #ocaml
lambda is now known as Guest37342
Guest37342 has quit [Client Quit]
mfp has joined #ocaml
env__ has quit [Ping timeout: 260 seconds]
kakadu has joined #ocaml
env__ has joined #ocaml
lopex has joined #ocaml
<discord>
<rgrinberg> @Drup so is the dev team still adamant about this?
haesbaert has joined #ocaml
<discord>
<rgrinberg> what's the issue with making people embed the interpreter in the binary?
env__ has quit [Ping timeout: 240 seconds]
<def`>
... the path to ocamlrun could also be discovered dynamically during invocation of the linker
env__ has joined #ocaml
env__ has quit [Ping timeout: 264 seconds]
env__ has joined #ocaml
env__ has quit [Ping timeout: 240 seconds]
env__ has joined #ocaml
<Drup>
But, that's not the only reason, isn't it ?
mengu has joined #ocaml
<Drup>
(for the fact that the compiler is not relocatable)
<Drup>
rgrinberg: no idea
<discord>
<rgrinberg> you mean there are other things that make it non relocatable?
mengu has quit [Ping timeout: 264 seconds]
<discord>
<rgrinberg> I'm not aware of any other issues and AFAIK in esy, the hack to rename interpreter names via sedding the binary is enough to relocate things
<def`>
the path to standard library is also hardcoded
<def`>
But can be overriden with environment variable
<def`>
look for absolute paths in the output of ocamlc -config
env__ has quit [Ping timeout: 240 seconds]
mengu has joined #ocaml
mengu has quit [Ping timeout: 240 seconds]
<discord>
<andreypopp> there's some other paths hardcoded in ocaml binaries — like path to ld.conf
<discord>
<andreypopp> but yeah, we relocate it with just path rewriting
mengu has joined #ocaml
mengu has quit [Remote host closed the connection]
mengu has joined #ocaml
mengu has quit [Read error: Connection reset by peer]
<discord>
<andreypopp> btw esy now supports (experimentally) opam metadata to construct sandboxes — given the opam project it is just esy install && esy build to install and build all the deps
env__ has joined #ocaml
andreypopp has joined #ocaml
env__ has quit [Ping timeout: 256 seconds]
mahem1 has joined #ocaml
<Leonidas>
Drup: thanks :) It is odd to see a binary file with a shebang but it makes a lot of sense, really
<Leonidas>
I just had to look up what this 'esy' is that people are talking about
<Leonidas>
it would be cool if opam could relocate an existing switch instead of rebuilding as a stopgap solution
kroot_ has joined #ocaml
al-damiri has joined #ocaml
env__ has joined #ocaml
env__ has quit [Ping timeout: 268 seconds]
env__ has joined #ocaml
env__ has quit [Ping timeout: 240 seconds]
mbuf has quit [Quit: Leaving]
env__ has joined #ocaml
env__ has quit [Ping timeout: 248 seconds]
groovy2shoes has quit [Excess Flood]
FreeBirdLjj has joined #ocaml
groovy2shoes has joined #ocaml
env__ has joined #ocaml
Haudegen has joined #ocaml
letoh has joined #ocaml
FreeBirdLjj has quit [Ping timeout: 244 seconds]
env__ has quit [Ping timeout: 240 seconds]
env__ has joined #ocaml
<discord>
<rgrinberg> The cool thing about esy is that it does this for libraries as well as compilers btw Leonidas
<discord>
<rgrinberg> Although dune will make this feature available for both soon enough
<Leonidas>
\o/
<discord>
<rgrinberg> @andreypopp what's with esy mixing both reaosn and ocaml 😛
env__ has quit [Ping timeout: 256 seconds]
<discord>
<rgrinberg> I also don't quite understand why esy needs empty opam files. You're not publishing any libraries, right?
<discord>
<andreypopp> @rgrinberg good point! I probably can remove them, I think I kept them b/c jbuild didn't want to build anything with jbuilder build if there's no public units defined, IIRC.
<discord>
<rgrinberg> Well if your binary uses all those libs then it wouldn't be a problem
<discord>
<andreypopp> but binary needs *.opam file iirc, need to recheck
<discord>
<rgrinberg> Yes, but only 1 😃
<discord>
<rgrinberg> A binary may belong to only a single package
<discord>
<rgrinberg> so just having esy.opam would suffice I think
<discord>
<andreypopp> ok, makes sense
env__ has joined #ocaml
<discord>
<rgrinberg> I'll make a PR
<discord>
<andreypopp> btw, would it be possible to get rid of opam files completely?
<discord>
<rgrinberg> It would be, but why? it would just inconvenience opam users for no reason I tihnk
<discord>
<rgrinberg> I think it's probably not too difficult to keep esy building with opam, so why not have it
tarptaeya has quit [Ping timeout: 265 seconds]
<discord>
<andreypopp> for other esy projects it is just boilerplate, we would like to provide esy opam-publish which would generate *.opam file automatically from esy metadata
<discord>
<andreypopp> so having empty opam file sitting is confusing when you don't use opam at all
<discord>
<rgrinberg> you'd still wanna check them in however
<discord>
<rgrinberg> otherwise it wouldn't be useful for opam users
<discord>
<rgrinberg> we are looking into generating opam files from dune btw
<discord>
<rgrinberg> Also, why does esy-build-package exists? It can't be in esy.opam?
<discord>
<rgrinberg> same for esyi
<discord>
<andreypopp> it probably can be inside esy opam package, I'm not sure, as I said the situation with relation from dune to opam files is confusing for me
env__ has quit [Ping timeout: 245 seconds]
<discord>
<rgrinberg> I'll shove them all into esy.opam. If you don't want to deal with opam too much, it makes sense to minimize the number of opam packages then
<discord>
<andreypopp> esy-build-package uses much less dependencies so it can be compiled with ocamlc and then distributed in bytecode form alone
<discord>
<andreypopp> thanks!
<discord>
<rgrinberg> I see
<discord>
<rgrinberg> okay, so it makes sense for it to have its own opam package
<discord>
<rgrinberg> well opam files at this point just contain lots of redundant stuff
<discord>
<rgrinberg> But esy is planning to generate dune files as well I suppose
<discord>
<rgrinberg> Honestly, I'm not sure how that would work while still retaining the full power of dune. But it would be nice to have a minimal set of boilerplate
<discord>
<andreypopp> @rgrinberg no plans for generating dune for now (as far as I know)... but we were looking into that
<discord>
<andreypopp> I had a prototype which generated dune stanzas from JSON config inside package.json using dunelib, it was nice but as I understand dunelib is private still
<discord>
<rgrinberg> that's just a simple technical problem however
<discord>
<rgrinberg> bigger issues are things like making the error messages good and making sure you aren't exposing only a subset of dune
<reynir>
it's weird seeing discord having a conversation with itself ^^
env__ has joined #ocaml
<discord>
<andreypopp> I agree, and I think exposing dune as-is is a good decision for now. I'd like to remove unnecessary boilerplate though — *.opam files.
<discord>
<rgrinberg> Yup. We'll do it in dune as well
<discord>
<andreypopp> (well not so minimal as it has different dirs for lib and executable, but still)
<discord>
<rgrinberg> you don't need a library if you're just making a binary of course
<discord>
<andreypopp> yes, I understand, just a minimal viable example, so people could see how to define both libs and executable
<discord>
<rgrinberg> one issue with generating opam files from dune is that we need a reverse map from lib names to packages
<discord>
<rgrinberg> When all the packages use dune, this is trivial. But some old school packages have some really creative differences here
env__ has quit [Ping timeout: 240 seconds]
<discord>
<rgrinberg> does esy have a package <=> lib map?
<discord>
<andreypopp> well, it has b/c each package has its own prefix — so we could query all libs inside a package
<discord>
<andreypopp> but vice versa — not sure it makes sense with esy
<discord>
<rgrinberg> what do you mean each package has its own prefix?
<discord>
<andreypopp> esy installs each packages into its own "prefix" path — a directory with bin, lib and so on.
<discord>
<andreypopp> so it's possible to construct an env for findlib which has only certain packages
<discord>
<andreypopp> it works like Nix in this regard
<discord>
<rgrinberg> yeah, though we simply need a name map in this case
keep_learning has quit [Quit: Ping timeout (120 seconds)]
ollehar has joined #ocaml
<ollehar>
is there a language which combines linear types with algebraic effects?
<discord>
<rgrinberg> esy could be really useful to dune for testing things btw. but it's really annoying that esy itself uses ppx :/ it makes bootstrapping it for dune more annoying than it should be
env__ has joined #ocaml
raduom has quit [Read error: Connection reset by peer]
<discord>
<andreypopp> @rgrinberg I'm all for removing ppx usage if we can work out some alternative...
<discord>
<rgrinberg> I'm afraid the only alternative I have is the good ole one
<discord>
<rgrinberg> but I think that avoiding ppx for foundational packages is reasonable
<discord>
<rgrinberg> but using reason isn't 😛
<discord>
<rgrinberg> go figure
<discord>
<andreypopp> I wish dune had a mode to promote ppx so we can have simpler bootstrapping story 😛
<discord>
<rgrinberg> It was rejected unfortunately as you are aware
env__ has quit [Ping timeout: 240 seconds]
<discord>
<rgrinberg> Anyway, this wasn't particularly attractive to me
_andre has joined #ocaml
env__ has joined #ocaml
andreypopp has quit [Quit: Connection closed for inactivity]
env__ has quit [Ping timeout: 264 seconds]
env__ has joined #ocaml
env__ has quit [Ping timeout: 248 seconds]
Haudegen has quit [Read error: Connection reset by peer]
env__ has joined #ocaml
env__ has quit [Ping timeout: 256 seconds]
env__ has joined #ocaml
<discord>
<Bluddy> Promote ppx?
<discord>
<Bluddy> What was the suggestion?
<discord>
<Bluddy> I'd love for some ppx tools to become standard within dune. Is this what was proposed?
<discord>
<Bluddy> ok this is not something I think is a good idea. glad it got rejected
<discord>
<andreypopp> curious why you think this is not a good idea?
dakk has joined #ocaml
env__ has joined #ocaml
<discord>
<Bluddy> aside from complexity and bugs, i think it would encourage bad practices, and make visible code less readable. we want the cleanliness of ppx-using code to persist.
<discord>
<Bluddy> but I do think it's time to consider whether certain ppxs should be integrated into the compiler.
<discord>
<Bluddy> or even have dune run them by default.
steenuil has quit [Remote host closed the connection]
env__ has quit [Ping timeout: 244 seconds]
<companion_cube>
I'm a pessimistic person, but good luck adding ppxs to the compiler…
nicoo has quit [Remote host closed the connection]
FreeBirdLjj has joined #ocaml
kleimkuhler has joined #ocaml
nicoo has joined #ocaml
env__ has joined #ocaml
env__ has quit [Ping timeout: 265 seconds]
theglass has quit [Ping timeout: 260 seconds]
env__ has joined #ocaml
neatonk1 has joined #ocaml
neatonk has quit [Ping timeout: 260 seconds]
neatonk1 is now known as neatonk
theglass has joined #ocaml
theglass has quit [Changing host]
theglass has joined #ocaml
kleimkuhler has quit [Quit: kleimkuhler]
kleimkuhler has joined #ocaml
env__ has quit [Ping timeout: 264 seconds]
ollehar has quit [Ping timeout: 244 seconds]
spew has joined #ocaml
env__ has joined #ocaml
env__ has quit [Ping timeout: 256 seconds]
kleimkuhler has quit [Quit: kleimkuhler]
env__ has joined #ocaml
FreeBirdLjj has quit [Remote host closed the connection]
env__ has quit [Ping timeout: 276 seconds]
env__ has joined #ocaml
FreeBirdLjj has joined #ocaml
env__ has quit [Ping timeout: 240 seconds]
env__ has joined #ocaml
env__ has quit [Ping timeout: 256 seconds]
env__ has joined #ocaml
env__ has quit [Ping timeout: 240 seconds]
env__ has joined #ocaml
env__ has quit [Ping timeout: 264 seconds]
env__ has joined #ocaml
env__ has quit [Ping timeout: 240 seconds]
env__ has joined #ocaml
env__ has quit [Ping timeout: 268 seconds]
dakk has quit [Remote host closed the connection]
env__ has joined #ocaml
env__ has quit [Ping timeout: 256 seconds]
env__ has joined #ocaml
env__ has quit [Ping timeout: 240 seconds]
<discord>
<rgrinberg> Yeah, I think that Lwt has gotten a lot stronger over the years
<discord>
<rgrinberg> so the arguments for using Async are even less strong. However, async did gain jsoo support so it caught up a little on the portability front
<discord>
<rgrinberg> but the way we do things in dune seems best. Jeremie has mentioned on twitter that both async could just as easily be implemented on top of dune's fibers
env__ has joined #ocaml
<discord>
<rgrinberg> Which would mean they would have a compatible bind + other primitives
<discord>
<rgrinberg> And of course those who will use fibers directly will gain performance benefits as well
<Leonidas>
yes, I read diml talk about it
<Leonidas>
would certainly be interesting
<discord>
<rgrinberg> what I think would make sense is making dune.fiber public and start letting people experiment with it
<Leonidas>
though this is only interesting if there is a chance of async using them
<ZirconiumX>
I mean, if Multicore OCaml with effects comes through, that might obsolete all of these
<Leonidas>
if only Lwt supports it then you only shifted the problems
<Leonidas>
ZirconiumX: I was wondering if that would happen.
<discord>
<rgrinberg> Luckily, Jeremie also maintains async 😃
<companion_cube>
ZirconiumX: not before years, and only in new versions, which wouldn't solve the problem for many people for years
<discord>
<rgrinberg> I would not hold my breath for fibers
<discord>
<rgrinberg> I mean for effects
<discord>
<rgrinberg> and even then fibers might not make it to js
<ZirconiumX>
Thus the important word "might"
dedgrant has joined #ocaml
<Leonidas>
hows async/lwt on BS?
env__ has quit [Ping timeout: 244 seconds]
<discord>
<rgrinberg> Bad? Nobody wants to support 4.02.3 forever or maintain a parallel (and vastly inferior) build system around
<discord>
<rgrinberg> Btw, I wonder why everyone is so eager for direct style now all of a sudden
<companion_cube>
because monads suck?
<Leonidas>
but I get called out for spreading FUD? :-(
<discord>
<rgrinberg> there's already a direct style co-operative threading lib in delimcc today
<discord>
<rgrinberg> you're free to use it
<companion_cube>
especially when we have a realistic way to get rid of IO monads in the future
<companion_cube>
delimcc is a bit too magical, I think :D
<discord>
<rgrinberg> The opposite, I think 😃 It already works with jsoo for example
<Leonidas>
I would enjoy monadic style a bit more with modular implicits
<discord>
<Perry> But that demands the existence of modular implicits, and when I mention them, people throw bricks at me. 😃
<companion_cube>
so, in 5 years of so? :D
<discord>
<rgrinberg> I'd be happy if %map and %bind made it to the compiler personally 😃
<companion_cube>
or*
<discord>
<rgrinberg> a far less invasive change that will greatly benefit a lot of existing code
<Leonidas>
rgrinberg: then I'd prefer a nicer do-style notation
<discord>
<rgrinberg> delimcc always supported bytecode ocaml so yeah
<companion_cube>
ouch
<Armael>
uh
<Armael>
wait
<Armael>
that doesn't mean jsoo supports it right?
<discord>
<rgrinberg> I think that waiting for a nicer do notation would mean that we'd essentially get anything
<companion_cube>
regarding %bind, I feel like the little Lwt I wrote was always either requiring try%lwt, or using a lwt+result monad
<companion_cube>
which is really really annoying
<companion_cube>
Armael: yeah, I'm also puzzled
env__ has joined #ocaml
<discord>
<rgrinberg> Hmm, now i'm having a hard time coming up with citations
<companion_cube>
delimcc does super dirty stuff with the stack…
<Armael>
I mean, to get delimited continuations you either need direct support of the runtime or at least do a non-modular transformation on the program
<Armael>
js doesn't give you 1), and I don't think jsoo does 2)
<Drup>
Armael: but then how is delimcc implemented for bytecode ?
<discord>
<rgrinberg> doing dirty stuff with the stack doesn't like it should be an issue with ocaml bytecode, right
<Armael>
Drup: yea I dunno
env__ has quit [Ping timeout: 240 seconds]
<Drup>
rgrinberg: You don't have raw access to bytecode instructions, so kinda, yes
<companion_cube>
it's the same stack as native code, isn't it?
FreeBirdLjj has quit [Remote host closed the connection]
mahem1 has left #ocaml [#ocaml]
<discord>
<rgrinberg> hmm it probably doesn't work in jsoo, at the very least you'd need some js stubs for the C primitives.
ygrek has joined #ocaml
<Armael>
Drup: mmm but so in bytecode there's C stubs that use the runtime API
<Armael>
you probably can't do that in js
<Drup>
rgrinberg: which you won't be able to provide :p
<companion_cube>
maybe with async/await? :D but that's far too high level
<Drup>
That's like trying to fold origami with a sledge hammer
<reynir>
hm, actually I'm wondering if using a sledge hammer is useful for flattening dense folds
<companion_cube>
so… perfectly suited for JS?
<ZirconiumX>
It's possible, you just need a very small sledge hammer
<companion_cube>
"it's the world's tiniest open source sledge hammer"
<ZirconiumX>
Somebody has got to name a project after that
env__ has joined #ocaml
<companion_cube>
well I definitely know a project named "sledge hammer" :p
env__ has quit [Ping timeout: 256 seconds]
env__ has joined #ocaml
env__ has quit [Ping timeout: 240 seconds]
<reynir>
I renamed one of my projects to origami-sledgehammer \o/
<Drup>
I expect royalties for that
<companion_cube>
Leonidas: do you have rights to the msgpck repo? just curious