adrien changed the topic of #ocaml to: Discussions about the OCaml programming language | http://www.ocaml.org | OCaml 4.09 release notes: https://caml.inria.fr/pub/distrib/ocaml-4.09/notes/Changes | Try OCaml in your browser: http://try.ocamlpro.com | Public channel logs at http://irclog.whitequark.org/ocaml
hlisp has quit [Remote host closed the connection]
jao has quit [Ping timeout: 256 seconds]
hlisp has joined #ocaml
hlisp has quit [Ping timeout: 256 seconds]
ygrek has quit [Ping timeout: 260 seconds]
jao has joined #ocaml
olle_ has quit [Ping timeout: 256 seconds]
olle has joined #ocaml
jao has quit [Remote host closed the connection]
jao has joined #ocaml
jao has quit [Ping timeout: 246 seconds]
jao has joined #ocaml
hlisp has joined #ocaml
ygrek has joined #ocaml
hlisp has quit [Ping timeout: 256 seconds]
hlisp has joined #ocaml
trn has joined #ocaml
<trn> Hi guys, the opam SSL cert expired today, just reporting.
<trn> Websites prove their identity via certificates, which are valid for a set time period. The certificate for opam.ocaml.org expired on 5/6/2020.
<trn> Can't opam init a new system :(
<ebb> Someone's had the wisdom to open a GitHub issue at https://github.com/ocaml/opam-repository/issues/16373
<trn> It's not a bad cert, it's that it actually expiored a few hours ago :b
<trn> s/not a bad weget or config error/
hlisp has quit [Ping timeout: 260 seconds]
<trn> opam init github git+https://github.com/ocaml/opam-repository.git -vv apparently worked, their SSL cert didn't expire :b
<trn> Anyway, I hope someone can easily fix that :(
hlisp has joined #ocaml
kark has quit [Quit: ZNC 1.7.2+deb3 - https://znc.in]
mfp has quit [Ping timeout: 272 seconds]
kark has joined #ocaml
amiloradovsky has joined #ocaml
hlisp has quit [Remote host closed the connection]
hlisp has joined #ocaml
ferd has quit [Ping timeout: 256 seconds]
hlisp has quit [Ping timeout: 256 seconds]
dborisog has joined #ocaml
hlisp has joined #ocaml
dborisog has quit [Ping timeout: 272 seconds]
hlisp has quit [Remote host closed the connection]
kvda has joined #ocaml
hlisp has joined #ocaml
kvda has quit [Client Quit]
kvda has joined #ocaml
jao has quit [Ping timeout: 256 seconds]
pigeonv has quit [Ping timeout: 272 seconds]
kvda has quit [Ping timeout: 260 seconds]
kvda has joined #ocaml
ferd has joined #ocaml
tizoc has quit [Quit: Coyote finally caught me]
tizoc has joined #ocaml
hlisp has quit [Remote host closed the connection]
hlisp has joined #ocaml
hlisp has quit [Remote host closed the connection]
hlisp has joined #ocaml
hlisp has quit [Remote host closed the connection]
spew has joined #ocaml
spew has quit [Client Quit]
hlisp has joined #ocaml
vicfred has quit [Remote host closed the connection]
vicfred has joined #ocaml
ygrek has quit [Ping timeout: 260 seconds]
hlisp has quit [Remote host closed the connection]
hlisp has joined #ocaml
narimiran has joined #ocaml
hlisp has quit [Ping timeout: 256 seconds]
hlisp has joined #ocaml
mbuf has joined #ocaml
hlisp_ has joined #ocaml
hlisp has quit [Ping timeout: 272 seconds]
sz0 has quit [Quit: Connection closed for inactivity]
sz0 has joined #ocaml
kvda has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
hlisp_ has quit [Remote host closed the connection]
hlisp has joined #ocaml
hlisp has quit [Ping timeout: 260 seconds]
kvda has joined #ocaml
hlisp has joined #ocaml
kvda has quit [Quit: Textual IRC Client: www.textualapp.com]
bartholin has quit [Ping timeout: 264 seconds]
bartholin has joined #ocaml
aecepoglu[m] has quit [*.net *.split]
undu[m] has quit [*.net *.split]
jimt[m] has quit [*.net *.split]
keep-learning[m] has quit [*.net *.split]
rfv has quit [*.net *.split]
rom1504 has quit [*.net *.split]
Leonidas has quit [*.net *.split]
cbarrett has quit [*.net *.split]
rfv has joined #ocaml
undu[m] has joined #ocaml
rom1504 has joined #ocaml
keep-learning[m] has joined #ocaml
jimt[m] has joined #ocaml
aecepoglu[m] has joined #ocaml
Leonidas has joined #ocaml
cbarrett has joined #ocaml
Haudegen has joined #ocaml
rfv has quit [Max SendQ exceeded]
rfv has joined #ocaml
<Leonidas> trn: it's a good cert, bront.
<Leonidas> I mean, I greatly appreciate the work of opam maintainers and all, but the certificate expiring has been a thing happening so often, it is becoming really annoying that it hasn't been properly addressed.
aspiwack[m] has quit [Quit: killed]
prsafont[m] has quit [Quit: killed]
lnxw37d4 has quit [Quit: killed]
dash has quit [Quit: killed]
keep-learning[m] has quit [Quit: killed]
jimt[m] has quit [Quit: killed]
sepp2k has quit [Quit: killed]
samrat[m] has quit [Quit: killed]
labor[m] has quit [Quit: killed]
camlriot42 has quit [Quit: killed]
bglm[m] has quit [Quit: killed]
flux1 has quit [Quit: killed]
ollehar_ has joined #ocaml
dabeanie[m] has quit [Quit: killed]
khady[m] has quit [Quit: killed]
schube[m] has quit [Quit: killed]
cgenie[m] has quit [Quit: killed]
Manis[m] has quit [Quit: killed]
aecepoglu[m] has quit [Quit: killed]
undu[m] has quit [Quit: killed]
peddie has quit [Quit: killed]
lubegasimon[m] has quit [Quit: killed]
mfp has joined #ocaml
amiloradovsky has quit [Remote host closed the connection]
amiloradovsky has joined #ocaml
flux1 has joined #ocaml
nullcone has quit [Quit: Connection closed for inactivity]
cheater has quit [Ping timeout: 272 seconds]
<ollehar_> test
labor[m] has joined #ocaml
aecepoglu[m] has joined #ocaml
aspiwack[m] has joined #ocaml
sepp2k has joined #ocaml
bglm[m] has joined #ocaml
dash has joined #ocaml
keep-learning[m] has joined #ocaml
camlriot42 has joined #ocaml
jimt[m] has joined #ocaml
lnxw37d4 has joined #ocaml
Manis[m] has joined #ocaml
peddie has joined #ocaml
khady[m] has joined #ocaml
undu[m] has joined #ocaml
samrat[m] has joined #ocaml
lubegasimon[m] has joined #ocaml
dabeanie[m] has joined #ocaml
cgenie[m] has joined #ocaml
prsafont[m] has joined #ocaml
schube[m] has joined #ocaml
galamadrabuyak has joined #ocaml
galamadrabuyak has quit [Remote host closed the connection]
hlisp has quit [Ping timeout: 264 seconds]
hlisp has joined #ocaml
abc_ is now known as abc
aquarel has joined #ocaml
abc is now known as abc_
aquarel has quit [Remote host closed the connection]
hlisp has quit [Remote host closed the connection]
hlisp has joined #ocaml
twister37 has joined #ocaml
twister37 has quit [Remote host closed the connection]
hlisp has quit [Ping timeout: 246 seconds]
hlisp_ has joined #ocaml
aquarel has joined #ocaml
hlisp_ has quit []
hlisp has joined #ocaml
jbrown has quit [Ping timeout: 258 seconds]
pigeonv has joined #ocaml
jbrown has joined #ocaml
Haudegen has quit [Quit: Bin weg.]
pigeonv has quit [Ping timeout: 240 seconds]
ygrek has joined #ocaml
hlisp has quit [Remote host closed the connection]
<ollehar_> any cool project coming to ocaml? multicore doesn't count
<ollehar_> projects*
hlisp has joined #ocaml
hlisp has quit [Ping timeout: 264 seconds]
pigeonv has joined #ocaml
aquarel has quit [Ping timeout: 264 seconds]
<Manis[m]> multicore should count double :-)
hlisp has joined #ocaml
<companion_cube> opam 2.1 is near
<ollehar_> no linear types or such?
<companion_cube> I mean, if we get multicore and algebraic effects in the next 10 years, it'll already be a win
Serpent7776 has quit [Read error: Connection reset by peer]
<ollehar_> slooooow
<ollehar_> is the compiler too big?
<ollehar_> maybe few resources.
<companion_cube> few resources, and it's hard to change a production-grade language without breaking things for existing users
<ollehar_> companion_cube: can ppx make things modular on language level?
<Drup> not really, no.
<ollehar_> D:
<ollehar_> ocaml never went the way haskell did, with {{ extensions }}, right?
<octachron> ppx only let you explore ligh syntax extension. Syntax is not the hardest part to change, by far.
<ollehar_> octachron: basically saying ppx happens too late in the compiler pipeline?
<octachron> Ppxs only ever touch the frontend.
<ollehar_> hm
<octachron> But yes, OCaml is still only one language, and not 2^(number of extensions) dialects like Haskell
<companion_cube> octachron: too early
<companion_cube> not too late
<Leonidas> companion_cube: ppx is a great way to break things for existing users on an ongoing basis :p
<ollehar_> ah
<companion_cube> Leonidas: I so agree
<companion_cube> ppx is a great way of writing non-forward-compatible code
<Armael> not writing code is the best way of writing forward-compatible code
<ollehar_> companion_cube: why?
<Leonidas> fortunately the latest ocaml features have been somewhat forgettable so I can just sit out on 4.09 or so for a while
<ollehar_> I'm very interested as type-state as a programming paradigm... Maybe I should ask some stackoverflow questions about it and OCaml...
<companion_cube> ollehar_: it depends on internal APIs of the compiler
<companion_cube> which are unstable :)
<companion_cube> Leonidas: we're trying to move to 4.08 from 4.06 :D
<ollehar_> companion_cube: well, if they're unstable, you can hardly blame the ppx authors, right?
<Leonidas> ollehar_: no, but PPX is (in retrospect) kinda a badly-thought out feature, which is hopefully remedied by the current ocaml-ppx effort :)
<ollehar_> the fuck
<ollehar_> ppx was supposed to fix camlp4?
<companion_cube> ollehar_: I don't blame the ppx authors
<companion_cube> but the ppx system
<ollehar_> bah
<companion_cube> (in retrospect)
<companion_cube> and yeah, +1 to Leonidas, it should have shipped with a stable AST from the start
<Leonidas> (in retrospect, exactly)
<Leonidas> the idea is sort of neat, really
Serpent7776 has joined #ocaml
dckc has quit [Quit: ZNC 1.6.6+deb1ubuntu0.2 - http://znc.in]
<ollehar_> any point of exposing deeper parts of the compiler with an API?
<ollehar_> like flamda AST
dckc has joined #ocaml
<companion_cube> it's all in compiler-libs
<companion_cube> and none of it is stable :)
<ollehar_> ah
Haudegen has joined #ocaml
<octachron> Complaining about the compiler evolving too slowly and asking for a stable internal API are a bit antinomic
<Drup> octachron: shut, they want to complain, don't spoil their fun
<companion_cube> I'm asking for people to not use internal APIs
<Armael> "ok boomer" ? :)
<ollehar_> If PHP can do it?
<companion_cube> 🤷
<companion_cube> Armael: if you can complain about me not using OCaml, I'll complain about people in OCaml doing things I don't like
<ollehar_> Or maybe PHP doesn't do it and just don't care if they break extensions
<companion_cube> complaining is a fundamental french right
<ollehar_> googling for "ocaml typestate" shows my blog :|
<ollehar_> Is Mezzo also INRIA?
<companion_cube> yes, but it's just a research lang
<ollehar_> Some people would call OCaml "just a research lang", haha
<ollehar_> but ok
<companion_cube> not exactly, it's used in production by many people
<companion_cube> and has for decades
<companion_cube> which is why, well, compatibility matters
<ollehar_> "
<ollehar_> The language of the future!
<ollehar_> "
<ollehar_> last commit: 2015
<ollehar_> :(
<ollehar_> companion_cube: yes, I know, just trolling
hlisp has quit [Remote host closed the connection]
<Armael> well yeah mezzo was a research experiment that was not carried on
<Armael> but it was cool indeed
<Drup> It was a cool puzzle, but I'm not sure I would call it usable :)
<Armael> 🤷
<ollehar_> I actually hope that typestate oriented programming will replace OOP in the future
<ollehar_> there's a paper (PDF) here if anyone is interested: https://www.cs.cmu.edu/~jssunshi/pubs/onward2009-state.pdf
<ollehar_> (from 2009)
<ollehar_> Basically replacing `class { }` with `state { }` in a Java-like syntax.
<simpson> ollehar_: The question is what might be gained. Many object-based concepts revolve around the idea that objects are individuals, or equivalently that the world of objects is open for modification. This, and not anything to do with types, is the main philosophical difference to examine between OCaml or other languages with objects.
<simpson> Indeed, OCaml's type system explicitly allows for duck-typing objects by their methods in order to allow for this open-world POV.
<ollehar_> duck-typing?
<ollehar_> simpson: what's to be gain is in the paper
<Drup> typestates just plain don't work with inference
<ollehar_> but: the protocol of a class cannot be encoded in the type-system in OOP
<ollehar_> Drup: yeah?
<Drup> it's fundamentally incompatible with full inference as is the tradition in OCaml
<ollehar_> Drup: But you can already "kind of" do it in OCaml with phantom types and monads?
<Drup> no, you can't do typestate, you can do phantom types
<companion_cube> full inference was a mistaaaake
<Drup> typestates allows you to **mutate the type of the object**
<ollehar_> Drup: yeah, but they overlap in use-case
<companion_cube> (besides it's gone in the times of GADTs)
<Drup> companion_cube: 1) that's like, your opinion 2) it's not gone, it's incomplete for a well determined subtype of the language. That's very different
narimiran has quit [Ping timeout: 256 seconds]
<ollehar_> subset* ?
<Drup> subset* yes
<companion_cube> 1) my opinion on the one adopted in almost all languages, including haskell devs :)
<Drup> companion_cube: haskell devs have a hard on for dependent types, which is why they go that way
<Drup> I'm not convinced that's any good idea to make a usable, convenient language (and dependent haskell is everything but convenient)
<Drup> (as for the rest of the languages .. full inference is harder to design, so many language designer go the easy way and give up)
<Drup> ollehar_: the difference between typestates and phantom types+linearity is exactly the difference between imperative and functional programming, just at the typelevel
<Drup> yes, "they overlap in use-case", but they don't go at it the same way
<ollehar_> hm hm hm
<ollehar_> Drup: Are you talking from the perspective of the coder or the compiler?
<Drup> in practice, typestate causes lot's of issues (adding mutations in your type system causes a mess, who would have though ?!). Even the Rust people gave it up for simply phantom types+linearity (aka, session types)
<Drup> and you can already do session types in OCaml just fine
<Armael> "just fine"
<ollehar_> Drup: link to session types in ocaml?
<simpson> And folks have been explicitly coding finite state machines for decades. They're not pretty, but they work just fine. AFAICT the rest is syntax and type-checking.
<companion_cube> is that as "usable" as the HKT in OCaml?
<Drup> companion_cube: it works better :)
<companion_cube> in my grumpy opinion, ocaml isn't really well designed for clever type magic
<ollehar_> Drup: the links do not imply any compiler changes, right?
<companion_cube> better stick to a relatively reasonable superset of ML
<ollehar_> hm, no says it's out of the box :)
<ollehar_> I'm gonna print that paper \o/
<Drup> companion_cube: you tried SML didn't you ? Remind me how painful that was ? :p
<companion_cube> the syntax is
<companion_cube> I did say "reasonable superset", and mostly in the expression land
<companion_cube> (better matching, inline records, etc.)
<Drup> OCaml does a lot of things to make harder concept more usable without burdening the programmer too much, and most of those are not that visible
<ollehar_> Hm, so the Rust people finally got phantom types etc to work good?
<companion_cube> hum, you can make basic phantom types
<companion_cube> but rust also isn't particularly nice if you want to do type magic
<ollehar_> yes, I've seen
<ollehar_> syntax gets overloaded quick
<companion_cube> better treat it as a SML with manual memory allocation and linear types :p
<companion_cube> (also if you don't want compile time to skyrocket)
<ollehar_> Drup: thanks for the links!
<ollehar_> 16:12 Drup I'm not convinced that's any good idea to make a usable, convenient language (and dependent haskell is everything but convenient)
<ollehar_> that's the good thing about typestate, it's very easy to understand
<ollehar_> Maybe I can convert this blog post to OCaml? http://cliffle.com/blog/rust-typestate/
<Drup> that's just phantom type+linearity
<Drup> Rust people use the world "typestate" for things which are not what PL designer call "typestate"
nullcone has joined #ocaml
Anarchos has joined #ocaml
dborisog has joined #ocaml
<Drup> (Rust removed the ability to do real typestates directly years ago)
<Drup> (mostly because you could do everything with phantom type+linearity)
jao has joined #ocaml
<ollehar_> Drup: Will anyone care about the technical difference?
<ollehar_> If the code looks mostly the same?
<Drup> it really doesn't, you have to thread the state everywhere like a purely functional program in one and not in the other :)
<ollehar_> Drup: Not if you wrap it in a monad?
<Drup> monad doesn't make your functional code look imperatives
<Drup> it makes all code look functional :D
<def> #include <monad.h>
<ollehar_> Drup: yeah, but you can hide the state
<ollehar_> the manual labour is what's make it non-idiomatic, so I'm not sure I'd call it a "solved problem"
<def> you end up with an indexed monad and very complicated type (because the whole "type state" is stuffed in the monad)
<ollehar_> def: yeah, maybe it only works for one typestate object at a time.
<companion_cube> maybe it's not worth the complexity either
<ollehar_> having a language where typestate is idiomatic is very much worth it, IMO.
<ollehar_> but I'll have to look closer to the OCaml session thing tonight.
<ollehar_> typestate for java with annotations
<ollehar_> hm, says it depends on java compiler plugins :d
Anarchos has quit [Remote host closed the connection]
Anarchos has joined #ocaml
Anarchos has quit [Quit: Vision[0.10.3]: i've been blurred!]
emias has quit [Quit: WeeChat 2.3]
jao has quit [Remote host closed the connection]
dabeanie[m] has left #ocaml ["Kicked by @appservice-irc:matrix.org : Idle for 30+ days"]
cgenie[m] has left #ocaml ["Kicked by @appservice-irc:matrix.org : Idle for 30+ days"]
Haudegen has quit [Quit: Bin weg.]
ollehar_ has quit [Ping timeout: 240 seconds]
AmyWilleron has joined #ocaml
AmyWilleron has quit [Client Quit]
cheater has joined #ocaml
aquarel has joined #ocaml
jao has joined #ocaml
aquarel has quit [Ping timeout: 256 seconds]
nullcone has quit [Quit: Connection closed for inactivity]
aquarel has joined #ocaml
nullcone has joined #ocaml
Haudegen has joined #ocaml
Jesin has quit [Quit: Leaving]
Jesin has joined #ocaml
emias has joined #ocaml
<mbuf> Is there a better way in a (rule ... (action ...)) to run a command with sudo privileges? The following exits with error code 1. https://pastebin.com/m1jNvc4j
amiloradovsky has quit [Ping timeout: 240 seconds]
Anarchos has joined #ocaml
Anarchos has quit [Quit: Vision[0.10.3]: i've been blurred!]
mbuf has quit [Quit: Leaving]
waleee-cl has joined #ocaml
aquarel has quit [Ping timeout: 272 seconds]
sagax has quit [Ping timeout: 260 seconds]
narimiran has joined #ocaml
<Leonidas> sudo in dune sounds extremely wrong
dborisog has quit [Ping timeout: 272 seconds]
tane has joined #ocaml
ygrek has quit [Ping timeout: 246 seconds]
narimiran has quit [Ping timeout: 246 seconds]
sstc has joined #ocaml
sstc has quit [Quit: WeeChat 2.8]
sstc has joined #ocaml
sstc has quit [Client Quit]
sstc has joined #ocaml
sstc has quit [Client Quit]
sstc has joined #ocaml
sstc has quit [Client Quit]
sstc has joined #ocaml
sstc has quit [Client Quit]
sstc has joined #ocaml
tane has quit [Quit: Leaving]
ygrek has joined #ocaml
<olle> question is what changes would be required to the ocaml type system to make session types (or some kind of typestate) idiomatic enough to be included in the standard library
<olle> after all, we finally got List.find_opt
<olle> so in ten years we can get Printf.open_in_st (st for session type)?
hlisp has joined #ocaml
vicfred has quit [Quit: Leaving]
vicfred has joined #ocaml
hlisp has quit [Ping timeout: 240 seconds]
hlisp has joined #ocaml
pippijn_ has joined #ocaml
pippijn_ has quit [Client Quit]
hlisp has quit [Remote host closed the connection]
hlisp has joined #ocaml