nullcone has quit [Quit: Connection closed for inactivity]
Haudegen has quit [Ping timeout: 264 seconds]
Yagotzirck has quit [Quit: Leaving]
Jeanne-Kamikaze has quit [Ping timeout: 264 seconds]
Jeanne-Kamikaze has joined #ocaml
a-kiwi has joined #ocaml
mxns has quit [Ping timeout: 240 seconds]
GuerrillaMonkey has joined #ocaml
Jeanne-Kamikaze has quit [Ping timeout: 264 seconds]
GuerrillaMonkey has quit [Quit: Leaving]
Jeanne-Kamikaze has joined #ocaml
GuerrillaMonkey has joined #ocaml
GuerrillaMonkey has quit [Remote host closed the connection]
Jeanne-Kamikaze has quit [Ping timeout: 240 seconds]
GuerrillaMonkey has joined #ocaml
mfp has quit [Ping timeout: 260 seconds]
GuerrillaMonkey has quit [Ping timeout: 272 seconds]
mxns has joined #ocaml
mxns has quit [Ping timeout: 240 seconds]
vicfred has quit [Quit: Leaving]
waleee-cl has quit [Quit: Connection closed for inactivity]
shawnw has quit [Quit: Leaving]
a-kiwi has quit [Quit: Connection closed]
hlisp has joined #ocaml
hlisp has quit [Read error: Connection reset by peer]
webshinra has quit [Remote host closed the connection]
wingsorc has quit [Quit: Leaving]
vicfred has joined #ocaml
vicfred has quit [Max SendQ exceeded]
vicfred has joined #ocaml
ggole has joined #ocaml
<d_bot>
<Christophe> repair windows bootloader
decentpenguin has quit [Read error: Connection reset by peer]
webshinra has joined #ocaml
decentpenguin has joined #ocaml
narimiran has joined #ocaml
narimiran has quit [Remote host closed the connection]
narimiran has joined #ocaml
shawnw has joined #ocaml
Haudegen has joined #ocaml
<d_bot>
<ulrikstrid> Maybe it's possible to build a "headless" utop that runs as a server and then you can send it be lines?
<oni-on-ion>
emacs somewhat does this
<d_bot>
<wokalski> What I have in mind is building an LSP which will shell out to ocamllsp for autocomplete etc but for on hover event it’ll return a printed value like the one you’d get from the “headless”utop + a separate way to get the last expression result. In vscode I’d use notebook API to nicely pin the last expression to bottom. In vim I’d use the preview window for that.
<d_bot>
<ulrikstrid> Might be worth adding it to ocaml-lsp/OCaml platform of possible @wokalski
<d_bot>
<wokalski> I think it won't be "general" enough to deserve ocaml-lsp. For example I'm thinking of ways to use `dune utop`
Tuplanolla has joined #ocaml
FreeBirdLjj has joined #ocaml
<oni-on-ion>
seen merlin?
FreeBirdLjj has quit [Ping timeout: 260 seconds]
hnOsmium0001 has quit [Quit: Connection closed for inactivity]
<d_bot>
<wokalski> oni-on-ion: how is merlin related to toplevel?
<oni-on-ion>
do you understand what you are trying to make?
<d_bot>
<wokalski> Yes, I believe I have a good understanding 🙂
<oni-on-ion>
okay.
oni-on-ion has quit [Quit: Quit]
borne has joined #ocaml
narimiran has quit [Ping timeout: 260 seconds]
bartholin has joined #ocaml
_whitelogger has joined #ocaml
mfp has joined #ocaml
sunmaster has joined #ocaml
<d_bot>
<ulrikstrid> Anyone knows how to get libssl with 1.3 on alpine? preferably via depext
aaaaaa has joined #ocaml
tane has joined #ocaml
<d_bot>
<theangryepicbanana> Ok so I have a question about parsing something with menhir
<d_bot>
<theangryepicbanana> basically, I have this operator called a "cascade", and cascades can be "nested"
sunmaster has left #ocaml ["Leaving"]
<d_bot>
<theangryepicbanana> e.g. ```
<d_bot>
<theangryepicbanana> expr
<d_bot>
<theangryepicbanana> -> [outer1]
<d_bot>
<theangryepicbanana> --> [inner1]
<d_bot>
<theangryepicbanana> ---> [innerInner1]
<d_bot>
<theangryepicbanana> --> [inner2]
<d_bot>
<theangryepicbanana> -> [outer2]
<d_bot>
<theangryepicbanana> --> [inner3]```
<d_bot>
<theangryepicbanana> which can be interpreted as ```
<d_bot>
<theangryepicbanana> expr
<d_bot>
<theangryepicbanana> -> ([outer1]
<d_bot>
<theangryepicbanana> -> ([inner1]
<d_bot>
<theangryepicbanana> -> [innerInner1]
<d_bot>
<theangryepicbanana> )
<d_bot>
<theangryepicbanana> -> [inner2]
<d_bot>
<theangryepicbanana> )
<d_bot>
<theangryepicbanana> -> ([outer2]
<d_bot>
<theangryepicbanana> -> [inner3]
<d_bot>
<theangryepicbanana> )```
<d_bot>
<theangryepicbanana> I am wondering how I should go about parsing this
<d_bot>
<theangryepicbanana> the precedence looks something like (highest) `--->` > `-->` > `->` (lowest)
<d_bot>
<theangryepicbanana> like, can I do this with the `%right` thingy or will I have to do it some other way?
<d_bot>
<theangryepicbanana> I guess the best way to put this is that the operator has "infinite depth", and so does its precedence
<d_bot>
<Drup> you'll have to post-process that, I think
<d_bot>
<theangryepicbanana> yeah, I was afraid of that
<d_bot>
<theangryepicbanana> rip
<d_bot>
<Drup> well, actually, not necessarely, you might be able to use the same technique used to parse indentation sensitive languages in LR
<d_bot>
<theangryepicbanana> oh I didn't even think of that
<d_bot>
<Drup> your tokenizer would emit tokens for changes of indentation
<d_bot>
<theangryepicbanana> yeah I guess it works the same was as like python or whatever
bartholin has quit [Ping timeout: 240 seconds]
<d_bot>
<theangryepicbanana> hmm
<d_bot>
<theangryepicbanana> sounds tricky here, but that might work
<reynir>
is the leading -> a discord artifact or part of the code
<reynir>
(or something else)
<d_bot>
<theangryepicbanana> part of the code
<reynir>
Ah, I missed that it was a menhir question
<d_bot>
<theangryepicbanana> FWIW `a->[b]->[c]` (`[]` = method call) is basically the same as `begin a#b; a#c; a; end` in ocaml
<d_bot>
<Drup> That's not a very functional language :3
<d_bot>
<theangryepicbanana> (idk if my edits appear on IRC)
<d_bot>
<theangryepicbanana> yeah it's not really supposed to be lol
<d_bot>
<theangryepicbanana> it's based on the cascade feature from smalltalk and dart actually
<d_bot>
<theangryepicbanana> although cascades are usually trivial to parse, *nested* cascades really aren't in this case
<d_bot>
<theangryepicbanana> anyways, thanks for the help
webshinra has quit [Remote host closed the connection]
neiluj has quit [Ping timeout: 265 seconds]
sagax has quit [Read error: Connection reset by peer]
TheLemonMan has joined #ocaml
sunmaster has joined #ocaml
<sunmaster>
Hello, Ocaml is based on SML, right? And SML is formally proven - maybe the implementation or just the specification, don't know - ? But has Ocaml also a formal proof?
<companion_cube>
no, they share a common ancestor
<sunmaster>
you mean ML?
<def>
OCaml is not based on SML. It does not mean much to says that a "language is formally proven", however it is formally specified and I think the type system is proven sound. The closest thing to a formally proven implementation of SML is Cake ML (https://cakeml.org)
<def>
OCaml has no formal proof either, but parts of the language are proven
<companion_cube>
SML has a formal specification, though, doesn't it?
<sunmaster>
thanks
<def>
yep
<companion_cube>
(proven to be typesafe and stuff)
<Drup>
companion_cube: the dynamic semantic, not the compilation process. CakeML does that (but doesn't support the whole language just yet)
hnOsmium0001 has joined #ocaml
<companion_cube>
sure
<Armael>
cakeml doesn't try to be exactly SML
<Armael>
it's quite close, but it's a language on its own, AFAIK
<Drup>
well, there are no modules, for starters :)
<Armael>
that could make it a subset of SML, but it's also not that
<Armael>
eg they have a polymorphic equality, instead of the SML equality typeclass
<Armael>
I don't remember if there are other differencies
olle has joined #ocaml
<Armael>
(that's not to say that cakeml isn't great, it is!)
<sunmaster>
Interesting! There is much background in the ML family of languages.
borne has quit [Quit: WeeChat 2.9]
sagax has joined #ocaml
oni-on-ion has joined #ocaml
olle has quit [Ping timeout: 260 seconds]
sunmaster has quit [Ping timeout: 260 seconds]
neiluj has joined #ocaml
berberman_ has joined #ocaml
berberman has quit [Ping timeout: 260 seconds]
Jeanne-Kamikaze has joined #ocaml
ggole- has joined #ocaml
opweiqw_ has joined #ocaml
banjiewen_ has quit [Ping timeout: 260 seconds]
waleee-cl has quit [Ping timeout: 260 seconds]
robmyers has quit [Ping timeout: 260 seconds]
ggole has quit [Ping timeout: 260 seconds]
opweiqw has quit [Ping timeout: 260 seconds]
webshinra has joined #ocaml
banjiewen_ has joined #ocaml
waleee-cl has joined #ocaml
robmyers has joined #ocaml
sunmaster has joined #ocaml
steenuil has quit [Ping timeout: 246 seconds]
bjorkintosh has joined #ocaml
sunmaster has left #ocaml ["Leaving"]
ggole- has quit [Quit: Leaving]
neiluj has quit [Quit: Lost terminal]
Jeanne-Kamikaze has quit [*.net *.split]
sagax has quit [*.net *.split]
osa1 has quit [*.net *.split]
infinity0 has quit [*.net *.split]
TC01 has quit [*.net *.split]
yomimono has quit [*.net *.split]
<d_bot>
<EduardoRFS> As we're making a OCaml 5.0, can we enable backtraces by default?
jun has quit [*.net *.split]
companion_cube has quit [*.net *.split]
Armael has quit [*.net *.split]
brown121407 has quit [*.net *.split]
_ks has quit [*.net *.split]
def has quit [*.net *.split]
vodkaInf1rno has quit [*.net *.split]
<d_bot>
<EduardoRFS> There is any good reason against it?
Jeanne-Kamikaze has joined #ocaml
jun has joined #ocaml
TC01 has joined #ocaml
companion_cube has joined #ocaml
brown121407 has joined #ocaml
Armael has joined #ocaml
sagax has joined #ocaml
yomimono has joined #ocaml
vodkaInf1rno has joined #ocaml
osa1 has joined #ocaml
infinity0 has joined #ocaml
_ks has joined #ocaml
def has joined #ocaml
sagax has quit [Max SendQ exceeded]
<d_bot>
<Christophe> doesn't it hurt performance ?
Jesin has quit [Quit: Leaving]
Jesin has joined #ocaml
sagax has joined #ocaml
steenuil has joined #ocaml
<Leonidas>
what, ocaml 5.0?
GuerrillaMonkey has joined #ocaml
narimiran has quit [Ping timeout: 246 seconds]
Jeanne-Kamikaze has quit [Ping timeout: 260 seconds]