<Anarchos>
tizoc yes but i have to type always «:MerlinTypeOf» ? It is a bit long to use in daily usage, no ?
<tizoc>
Anarchos: it says "Bound to <LocalLeader>t by default in normal mode.", but I don't know how to interpret that, haven't used vim in a very long time
<Anarchos>
tizoc lolcalleader seems to be the 'g' key
<Anarchos>
tizoc no it is '\' i just made a test
<Anarchos>
tizoc it prints it in the bottom line though, not in a popup
<tizoc>
Anarchos: thats what it does on emacs, not sure how it works on vim
<tizoc>
Anarchos: I get an overlay with the type when autocompleting
connorjacobsen has quit [Remote host closed the connection]
<Algebr`>
good question, should be faq somewhere
tmtwd has joined #ocaml
yegods has quit [Remote host closed the connection]
<sveit>
also, is there a shortcut for constructions like the following: module WrappedInt : sig type t val makeWrappedInt : int -> t end = struct type t = int let makeWrappedInt i = i end?
<Algebr`>
I don't think so? What kind of shortcut could you imagine?
<Algebr`>
Shortcuts might be found in ReasonML
<sveit>
Algebr`: are you familiar with haskell?
<sveit>
this is basically the newtype construction from that language
<Algebr`>
yes familiar
<sveit>
the point is if i want to enforce type safety in a cost-free way, i can write newtype T a = ... as long as the right hand side has only one data parameter, and this is guaranteed to be completely free from the point of view of performance
<sveit>
the difference in ocaml is if i define type WrappedInt = int, WrappedInt and int actually look the same at least in that module
<sveit>
to the typechecker
<Algebr`>
I suppose you could wrap it with a constructor, but then you take a slight performance hit
<Algebr`>
Are you just starting with the language and already optimizing?
<sveit>
Algebr`: basically :) i switched from haskell to ocaml for the promise of performance (and now I really like functors over typeclasses)
<Algebr`>
silly idea, maybe get more familiar with the language before squeezing every bit out of it? Maybe a phantom type can be used for this? Don't know
MercurialAlchemi has quit [Ping timeout: 276 seconds]
sveit has left #ocaml ["ERC (IRC client for Emacs 24.5.1)"]
tmtwd has quit [Ping timeout: 244 seconds]
<Bluddy[m]>
sveit: In 4.04, wrapping a type in a single variant or in a single record field will be free.
<Bluddy[m]>
exactly like haskell's newtype
<Bluddy[m]>
I think there's an option that needs to be passed to the compiler (to prevent breaking backwards-compatibility by default) but that's it.
<Algebr`>
oh yea, I remember reading about that for 4.04
<Algebr`>
There's an open PR for it
MercurialAlchemi has joined #ocaml
Simn has joined #ocaml
d0nn1e has quit [Ping timeout: 240 seconds]
d0nn1e has joined #ocaml
<Drup>
(That optimization won't be enabled by default at first)
jimt_ has joined #ocaml
jimt has quit [Ping timeout: 252 seconds]
govg has joined #ocaml
slash^ has joined #ocaml
<Algebr`>
Anyone happen to know remote contract work available?
copy` has quit [Quit: Connection closed for inactivity]
chsn has joined #ocaml
<chsn>
is there anyway to do row types in ocaml?
jimt_ is now known as jimt
tane has joined #ocaml
Muzer has quit [Read error: Connection reset by peer]
Algebr`` has joined #ocaml
f[x] has joined #ocaml
stux|RC has quit [Read error: Connection timed out]
Algebr` has quit [Ping timeout: 276 seconds]
stux|RC-only has joined #ocaml
Muzer has joined #ocaml
Algebr`` has quit [Ping timeout: 258 seconds]
Algebr`` has joined #ocaml
mcc has quit [Quit: Connection closed for inactivity]
Algebr`` has quit [Ping timeout: 252 seconds]
govg has quit [Ping timeout: 244 seconds]
yegods has joined #ocaml
yegods has quit [Remote host closed the connection]
AltGr has joined #ocaml
tane has quit [Quit: Leaving]
bruce_r has quit [Ping timeout: 264 seconds]
kakadu has joined #ocaml
sh0t has joined #ocaml
Anarchos has joined #ocaml
tane has joined #ocaml
Algebr`` has joined #ocaml
kakadu has quit [Remote host closed the connection]
zpe has joined #ocaml
l1x has quit [Ping timeout: 260 seconds]
ggherdov has quit [Ping timeout: 260 seconds]
yegods has joined #ocaml
l1x has joined #ocaml
mbrock has quit [Ping timeout: 264 seconds]
yegods has quit [Remote host closed the connection]
<mrvn>
orbifx-m: One of my ocaml TODOs is to add a new custom block tag that has n ocaml values and m non ocaml values.
AlexDenisov has joined #ocaml
<orbifx-m>
To what?
<mrvn>
orbifx-m: to the GC
<orbifx-m>
Are you part of the devs or going to submit a patch?
<mrvn>
orbifx-m: submit a patch
<orbifx-m>
K
<mrvn>
orbifx-m: I also want something so you write your own custom ops for a ocaml type in ocaml.
<mrvn>
+can
Reshi has quit [Ping timeout: 258 seconds]
<orbifx-m>
And just to reiterate (I'm solidifying my understanding), the stack is also used for storing values, unboxed ones, and it's also traversed by the gc? To find root values?
<mrvn>
orbifx-m: only boxed values can be on the stack.
<mrvn>
or rather tagged values.
<mrvn>
the CAMLparam and CAMLlocal tell the GC where to find them.
<orbifx-m>
And are they regarded as root?
<mrvn>
till the CAMLreturn
adi___ has quit [Ping timeout: 258 seconds]
mfp has quit [Ping timeout: 264 seconds]
yegods has quit [Remote host closed the connection]
adi___ has joined #ocaml
yegods has joined #ocaml
<orbifx-m>
Ok, thanks, getting there. My next step is to look at the CAMLparam code
<orbifx-m>
Planning to write a small tutorial of something on my blog
<orbifx-m>
If you want we can collaborate on that.
ggole has joined #ocaml
thizanne has joined #ocaml
nicholasf has quit [Remote host closed the connection]
yegods has quit [Remote host closed the connection]
nicholasf has joined #ocaml
yegods has joined #ocaml
beginner has joined #ocaml
jbrown has quit [Ping timeout: 276 seconds]
govg has quit [Ping timeout: 264 seconds]
Algebr`` has joined #ocaml
mcc has joined #ocaml
jbrown has joined #ocaml
shinnya has joined #ocaml
nicholasf has quit [Remote host closed the connection]
mfp has joined #ocaml
StatelessCat has quit [Quit: WeeChat 1.5]
copy` has joined #ocaml
StatelessCat has joined #ocaml
StatelessCat has joined #ocaml
StatelessCat has quit [Changing host]
FreeBird_ has joined #ocaml
octachron has quit [Quit: Page closed]
FreeBirdLjj has quit [Ping timeout: 258 seconds]
Reshi has joined #ocaml
agarwal1975 has joined #ocaml
AlexDenisov has quit [Quit: My Mac has gone to sleep. ZZZzzz…]
jbrown has quit [Ping timeout: 265 seconds]
ansiwen has joined #ocaml
jbrown has joined #ocaml
AlexDenisov has joined #ocaml
bleuje has joined #ocaml
larhat has joined #ocaml
FreeBirdLjj has joined #ocaml
FreeBird_ has quit [Ping timeout: 265 seconds]
MercurialAlchemi has quit [Ping timeout: 265 seconds]
al-damiri has quit [Quit: Connection closed for inactivity]
<bleuje>
I'm making a mesh plotter for fun in OCaml, I wonder if anyone could be interested in using something like that.
yegods has quit [Remote host closed the connection]
ansiwen has quit [Remote host closed the connection]
ansiwen has joined #ocaml
ansiwen has quit [Remote host closed the connection]
ansiwen has joined #ocaml
kushal has joined #ocaml
nicholasf has joined #ocaml
yegods has joined #ocaml
ansiwen has quit [Remote host closed the connection]
ansiwen has joined #ocaml
nicholasf has quit [Ping timeout: 244 seconds]
Reshi has quit [Ping timeout: 260 seconds]
pierpa has joined #ocaml
beginner has quit [Quit: Leaving]
AlexDenisov has quit [Read error: Connection reset by peer]
AlexDenisov has joined #ocaml
aa has joined #ocaml
aa has quit [Client Quit]
govg has joined #ocaml
malc_ has joined #ocaml
bruce_r has joined #ocaml
jbrown has quit [Quit: Leaving]
malc_` has joined #ocaml
malc_ has quit [Ping timeout: 264 seconds]
mcc has quit [Quit: Connection closed for inactivity]
malc_`` has joined #ocaml
malc_`` has quit [Client Quit]
copy` has quit [Quit: Connection closed for inactivity]
malc_` has quit [Ping timeout: 244 seconds]
dakk has quit [Ping timeout: 244 seconds]
ansiwen has quit [Read error: Connection reset by peer]
sepp2k has quit [Quit: Leaving.]
ansiwen has joined #ocaml
bruce_r has quit [Ping timeout: 264 seconds]
jwatzman|work has quit [Quit: jwatzman|work]
chambart has joined #ocaml
AlexDenisov has quit [Quit: My Mac has gone to sleep. ZZZzzz…]
MercurialAlchemi has joined #ocaml
govg has quit [Ping timeout: 244 seconds]
govg has joined #ocaml
orbifx-m has quit [Ping timeout: 276 seconds]
bruce_r has joined #ocaml
mengu has joined #ocaml
mengu has joined #ocaml
mengu has quit [Changing host]
zpe has quit [Remote host closed the connection]
bleuje has quit [Ping timeout: 264 seconds]
sepp2k has joined #ocaml
larhat has quit [Remote host closed the connection]
bruce_r_ has joined #ocaml
bruce_r has quit [Ping timeout: 258 seconds]
sepp2k has quit [Ping timeout: 260 seconds]
AltGr has left #ocaml [#ocaml]
govg has quit [Ping timeout: 240 seconds]
ciniglio has joined #ocaml
ocaml176 has joined #ocaml
<ocaml176>
Hi, is it possible to use "module MyModule = struct ... end" in multiple places to define a single module?
<ggole>
No. However, you could define MyModule1, MyModule2, etc and then include them all
<ocaml176>
Thanks !
sepp2k has joined #ocaml
<ocaml176>
how to you make a module include the others (with open, so that I don't have to add "MyModule1." everywhere)?
<ocaml176>
how do you*
<Algebr``>
there's the include keyword
<Algebr``>
for modules
chambart has quit [Ping timeout: 276 seconds]
<ocaml176>
okay, is syntax "include module MyModule"?
<Algebr``>
include MyModule
mcspud has quit [Ping timeout: 250 seconds]
<ocaml176>
yeah I just figured it out :)
AlexDenisov has joined #ocaml
<Armael>
"include MyModule"
connorjacobsen has joined #ocaml
connorjacobsen has quit [Remote host closed the connection]
mcspud has joined #ocaml
connorjacobsen has joined #ocaml
<chsn>
does ocaml support record types?
<Algebr``>
type foo = {a: string; b: int}
connorjacobsen has quit [Remote host closed the connection]
Anarchos has joined #ocaml
shinnya has quit [Ping timeout: 260 seconds]
adelbertc has joined #ocaml
<ocaml176>
Now that I have my nice modules, I would like to make a documentation, is it easy to do with ocamldoc?
connorjacobsen has joined #ocaml
<Algebr``>
sort of, things made with (** *) are doc strings
nicholasf has joined #ocaml
<Algebr``>
I've never called ocamldoc directly, instead used oasis
FreeBirdLjj has quit [Remote host closed the connection]
manizzle has joined #ocaml
slash^ has quit [Read error: Connection reset by peer]
ocaml339 has quit [Quit: Page closed]
mengu has quit [Remote host closed the connection]
zpe has quit [Remote host closed the connection]
al-damiri has joined #ocaml
mengu has joined #ocaml
MercurialAlchemi has quit [Ping timeout: 276 seconds]
jbrown has joined #ocaml
nicholasf has joined #ocaml
AlexDenisov has quit [Quit: My Mac has gone to sleep. ZZZzzz…]
<companion_cube>
yay ocaml-sqlite \o/
<companion_cube>
meaning, sqlexpr
pyx has joined #ocaml
pyx has quit [Client Quit]
yegods has quit [Remote host closed the connection]
orbifx has joined #ocaml
<orbifx>
I've asked this before, but i forgot what was said then
<orbifx>
What are the most prominent web development frameworks in ocaml just now?
<Algebr``>
ocsigen, opium
<Algebr``>
afaik
<Algebr``>
I had written bindings to reactjs using jsoo
silver has quit [Quit: rakede]
kakadu has joined #ocaml
ansiwen has quit [Remote host closed the connection]
<orbifx>
not too interested at the moment with JS Algebr``
<orbifx>
any takes on oscigen and opium? I would like it to run behind NGinx potentially. Or is it better to have a web server build in and just proxy?
yegods has joined #ocaml
<Algebr``>
lol, you want to do web dev but not interested in js.
_andre has quit [Quit: leaving]
<orbifx>
yes ;)
<Algebr``>
good luck.
<orbifx>
(at the moment)
<orbifx>
thanks, should be fine
yegods has quit [Remote host closed the connection]
<kakadu>
hey, man
<orbifx>
hey kakadu
<companion_cube>
Algebr``: for web \ web-apps, no JS should be fine... shouldn't it? :p
<kakadu>
orbifx: I didn't get your last commit, btw. Why it is really needed/
<kakadu>
?
<Algebr``>
companion_cube: lol
<companion_cube>
(really, why shouldn't it?)
<Algebr``>
I will pass in silence.
<companion_cube>
e.g. for something like reddit, you shouldn't need much JS, I think
<companion_cube>
keep it simple
<Algebr``>
reddit will need JS, when you comment you are changing the DOm
<Algebr``>
but yes, overall reddit doesn't need that much JS
<companion_cube>
a reload could do
<orbifx>
technically no JS is needed, HTML doesn't require it.
<orbifx>
The improvements it offers are good for servers, JSON and all that, but at some point they just become a pest and burden for the browser
<Algebr``>
a reload is ugly/awful UI
<orbifx>
I'd like to see something back to basics.
<orbifx>
Algebr``: web pages were meant to be "pages"
<Algebr``>
which hasn't been the case since like 1995
<companion_cube>
for something simpler, like a website hosting documentation, you need even less JS, I think
<orbifx>
You want reload and liveliness, write an appp
<companion_cube>
(except maybe for search, but I'm not even sure)
<Algebr``>
companion_cube: yea, hosting docs, pure HTML/CSS is fine
<orbifx>
companion_cube: you need nil JS
<orbifx>
Making apps for phones is cool, but somehow making the for desktop is becoming extinct. Yet browsers needs gigs of memory to run now
<orbifx>
it's stupid
<Algebr``>
just opened safari, running with 150mb
<Algebr``>
making for the desktop is revived with electron
<orbifx>
what page?
<orbifx>
whatever electron is, you probably mean to say that you "expect" or "hope" to revive it.
<orbifx>
kakadu: because otherwise the _func causes a crash when it's moved
<Algebr``>
electron is a github project that lets you make cross platform desktop apps using just HTML/CSS/JS
d0nn1e has quit [Ping timeout: 265 seconds]
<kakadu>
what was using in the core of PopcornTime? Some like this perhaps.
<companion_cube>
it's used in atom I think
<orbifx>
Algebr``: so does QML... adoption does not depend on the what a project claims
<kakadu>
orbifx: But why it causes a crash?
<companion_cube>
(and maybe visual studio code)
d0nn1e has joined #ocaml
<orbifx>
kakadu: _func was being stored, and registered as a root, but you can't register a value from the heap apparently. It has to be outside the run-time's heap (i.e. malloc-ed in C)
<kakadu>
Which run-time heap?
<orbifx>
Algebr``, companion_cube: I don't know of any html+css+js renderer which is as light as running native apps.
<orbifx>
kakadu: ocaml's
<kakadu>
But container object is malloc'ed in C.
<Algebr``>
orbifx: I don't understand the argument. If you want to fiddle with native APIs, then do it, but I will be able to release a product 3 times faster and instantly on 3 platforms.
<Algebr``>
orbifx: I've written native apis on OS X/iOS. Its a pain in the ass and frankly a waste of time
<Algebr``>
no one cares what the backend, or what an app is implemented in, they just care if it works and if its in their hands.
<companion_cube>
does electron also work on alla mobile platforms?!
yegods has joined #ocaml
<companion_cube>
(including notifications, etc. integrated in the rest of the OS?)
<Algebr``>
companion_cube: I don't remember, probably not. integrating with the rest of iOS is not something easily done.
<Algebr``>
maybe the github readme has some updated info
<orbifx>
Algebr``: so you say, I disagree, but pointless to discuss it
<Algebr``>
orbifx: sorry, I don't mean to give that impression
Anarchos has quit [Quit: Vision[0.9.7-H-20140108]: i've been blurred!]
<Algebr``>
orbifx: there's definitvely a point, I agree, but there's new stuff like ReactNative which lets me write JavaScript and still have native performance on mobile.
<Algebr``>
that to me is the best I could ask for, easy language + native performance.
zpe has joined #ocaml
<Algebr``>
(fwiw, I have tried to integrate OCaml into stack as well)
<orbifx>
Algebr``: finding it hard to believe that you can get native performance with JS, but might be the case.
<Algebr``>
orbifx: agreed, you can look at the source of ReactNative, its basically exposing the native code to JS.
<orbifx>
If you are comparing it's performance with other apps that isn't a worthy benchmark in my book.
<orbifx>
As for "shipping", or releasing rather -- yeah it becomes faster. I get updates for my apps every day. They are just getting bigger and bigger. Wish their functionality improved too.
<Algebr``>
it would be like me exposing objc to OCaml, so whatever the cost of the FFI call, etc.
<orbifx>
So you are not doing any serious programming in it, just repacking functionality already available in libraries.
<Algebr``>
I don't know what 'serious programming' means. If you writing code, then you're programming..
<Algebr``>
Also when did using libraries become something that we should make fun of people for?
zpe has quit [Ping timeout: 244 seconds]
<Algebr``>
by this token only the C programmers are doing 'serious progrmaming'?
<kakadu>
only OCaml programmers do serious programming.
<kakadu>
:)
<Algebr``>
:)
ansiwen has quit [Remote host closed the connection]
bruce_r_ has quit [Ping timeout: 250 seconds]
<companion_cube>
Algebr``: "easy language" is a bit subjective
<companion_cube>
I would find java much easier than JS, if only because of types
<companion_cube>
and presence of decent IDEs
<Algebr``>
I use tern and it provides code completion, type info
<companion_cube>
you use typescript?
<Algebr``>
modern JS is/can be a bit cryptic
<Algebr``>
nah, just modern JS, ES6
<companion_cube>
hu
<Algebr``>
I did use jsoo a lot.
<companion_cube>
(how are the types inferred?)
<orbifx>
Algebr``: my point was missed. I'll try agai. A lot of functionality provided by apps I see today is a repackaging of something which has existed but re-implemented in something supposedly easier.
<Algebr``>
tern is an awesome project, http://ternjs.net/, author once posted an amazing breakdown of the type checker
<Algebr``>
and in anycase there flow type
<orbifx>
To give you an example.. Atom feeds are completely neglected and folk go and create custom apps, written in the latest JS toolkit to delivery news-updates.
<Algebr``>
also true
<Drup>
"no one cares what the backend, or what an app is implemented in, they just care if it works and if its in their hands. " <- I'm probably not the most common target, but that's not my case. I avoid things that are written in nodejs/ruby and that are not packaged in my system's package manager, because npm/gem are horible and break every single time I try to use them
<orbifx>
A viscious cicle of re-wrapping.
<companion_cube>
but I doubt even flow can infer types that are as accurate as, say, in java (since in java almost everything is typed by design, unlike many JS aAPIs)
<Algebr``>
yes, probably flow can't match Java, but you're starting for an actual type system rather than JS.
<Algebr``>
Drup: also agree
<orbifx>
JS is a plague.. a promise that everybody can have a shot at making something meaningful. I very much doubt it. It was meant to be for adding some niceties to HTML as far as I know.
<Algebr``>
orbifx: its not a promise, its a reality
<companion_cube>
Algebr``: indeed, and that's my point: to me JS is not an easy language
<companion_cube>
it's an untyped minefield with crazy semantics, getting slowly better
<Algebr``>
its not easy cause there are stupid corners
<Algebr``>
too many stupid corners.
<Drup>
Algebr``: also, I often see nice editor or terminal emulator written in javascript+html, and every one of them is slow as hell, so I avoid that too
<orbifx>
Algebr``: again.. if you say so
<Algebr``>
Drup: also true, atom editor is slow, but this is comparing it to people that use vim/emacs...what else would be faster?
<Drup>
anything written in a reasonable language
<Algebr``>
meh, intellij is also slow at times, pycharms hangs ocassionally too
<Drup>
emacs is not amazingly fast, you know
<companion_cube>
kate, gedit, etc. are quite fast, I think
<Algebr``>
lol, not amazingly fast, but fast enough
<companion_cube>
even sublime? not sure
<Algebr``>
hopefully emacs will get faster, now that I can write OCaml instead of elisp
<Algebr``>
will be interesting to see what comes of that
<Bluddy[m]>
guys don't get too attached to JS. WebAssembly is probably going to kick its butt.
<Drup>
not in the short/medium term.
<Bluddy[m]>
eh... a couple of years is my guess
<companion_cube>
can't wait for it :p
<Bluddy[m]>
think of the rate at which the web develops
<Algebr``>
no gc yet
<Algebr``>
but once that happens, then it ought to take off, maybe
<Bluddy[m]>
javascript has already been reduced to the fastest subset. the natural conclusion is a bytecode format.
<Drup>
no gc is not the only concern. You can't call any JS APIs either.
<Drup>
and website that don't call the DOM or other APIs are not incredibly useful
<Algebr``>
+1
<Bluddy[m]>
webassembly is in the financial interest of every single major company in the web space. It'll all happen.
<Drup>
and given the amount of stuff you need to start to be able to call those APIs (like a language that now how to represent all the types that are representable in javascript ...), I don't expect it that soon
<Drup>
Oh, it will
<Drup>
I have no doubt
<Drup>
Just not that soon
<Drup>
webassembly is good at representing C
<companion_cube>
and rust
<Drup>
companion_cube: well, anything llvm emits
<Drup>
:p
<orbifx>
has anyone used both oscigen and opium?
<orbifx>
kakadu: are you going to bump versions on OPAM for lablqt?
<kakadu>
I need to deal with this issue about _func
<kakadu>
I do not yet understand why crash is happening
<orbifx>
let me know when you have time to discuss it
<orbifx>
my xmpp server might be playing up, transfered the domain
connorjacobsen has joined #ocaml
<Bluddy[m]>
orbifx: well, FWIW i tried to install ocsigen eliom and the version on opam isn't compatible with 4.03. You have to pin to master, and even then I couldn't install via opam.
<orbifx>
Bluddy[m]: did you go for opium then?
<Bluddy[m]>
no haven't tried it yet. eliom seemed really cool since it integrates client and server. I wanted to try it out.
<Bluddy[m]>
it's very discouraging when key parts of the OCaml ecosystem don't keep up with opam/ocaml versions
ansiwen has joined #ocaml
<companion_cube>
I think Drup is working on a ppx version of eliom?
<companion_cube>
it should work better on newer versions
<Bluddy[m]>
I can only imagine what it makes new users (who aren't dedicated to ocaml) think
<Algebr``>
Bluddy[m]: it makes them leave and never come back
agarwal1975 has quit [Quit: agarwal1975]
<Algebr``>
so only the most dedicated stay and think that everything is great.
sepp2k has quit [Quit: Leaving.]
<orbifx>
not a bad filter ey? :P
<Algebr``>
I think that's an echo chamber.
<companion_cube>
I don't think anyone thinks that the OCaml ecosystem is great
<companion_cube>
(the language, sure; the ecosystem, I've yet to meet them)
<orbifx>
it's not bad
<orbifx>
might get there in the end
<Bluddy[m]>
This is the same problem haskell has faced: you can't rely on volunteers to keep their packages up to date. People have lives and stuff, and their degree of commitment changes.
<Bluddy[m]>
I think you want a looser model, where the community can go around and patch up the broken windows.
<Algebr``>
well everything has to funnel through opam now, with the inevitable delays and comments.
<gasche`>
the problem with Eliom is not about broken windows, it is that there are API changes that were made along with 4.03 compatibility changes
<gasche`>
(which is probably not great, but not unreasonable either as (1) new stdlib features suggest some API changes and (2) js_of_ocaml may require changes anyway when there are large-ish runtime changes in the newer OCaml versions)
<orbifx>
Bluddy[m]: true. I'll add that we need to start get some solid basis for long-life designs, rather than projects on floating icecubes
<Bluddy[m]>
Package maintainers or even users should be able to advertise their problems to achieve compatibility in a central location -- an OCaml platform problem list.
<Algebr``>
Bluddy[m]: there is one, opam had this nice web UI that showed all busted packages
<gasche`>
( opam builder, improved mostly by Fabrice Le Fessant )
<Bluddy[m]>
That's good, but I would suggest that that's only the first step. A priority-based issue tracker for the OCaml platform would be more useful. Some packages are rarely touched and thus not worth spending community effort on.
<tizoc>
W: Use InterfacePatterns or ImplementationPatterns to define this file with feature "source_patterns".
<Drup>
Given that bucklescript doesn't respect the OCaml memory model (and hence won't be compatible with a significant portion of the OCaml ecosystem) ...
<Bluddy[m]>
woah what? Could you explain?
<Drup>
it has a memory model that is closer to the natural translation to javascript
<Algebr``>
BS isn't made to play nicely with other OCaml code, from what I understand. Its like OCaml but with the web/JS in mind first.
<Drup>
it's not OCaml
<Bluddy[m]>
That sucks massively.
<Drup>
it's the syntax and the type system of OCaml, but the javascript memory model/semantics
<Algebr``>
less massively when you consider that the npm community, ecosystem is like 150x larger.
<Bluddy[m]>
OK, well it sucks for me personally massively.
mengu has quit [Remote host closed the connection]
<gasche`>
Drup: in the future it would be best to pressure people in the Ocsigen community to do minor release that build under new OCaml releases, and not link such compatibility releases with breaking API changes
<Drup>
Bluddy[m]: on the other hand, do you have any reasons to use bucklescript ?
<Drup>
gasche`: I agree, but I was not in charge of that one
<gasche`>
of course
<Drup>
gasche`: I'm not very happy about the situation either
<Bluddy[m]>
Drup: no, but it looks nice. Code is clear and minimal. The concept of working off of Lambda rather than the bytecode seems to make sense performance-wise, at least from afar.
nicholasf has quit [Remote host closed the connection]
<Drup>
bucklescript doesn't have better perfs than jsoo
<Algebr``>
to me having the syntax, type system of OCaml + the entire npm ecosystem is like nirvana
nicholasf has joined #ocaml
<Bluddy[m]>
Drup: it doesn't? Code size seems much better at least.
<Drup>
Bluddy[m]: once minimized ?
<Bluddy[m]>
Drup: Um... I dunno. I don't have experience with either implementation. Bucklescript looks shiny and has fancy words on its web page. I'm the doofus who just tried to install eliom and failed, remember?
<Drup>
Algebr``: the cost of giving type signatures to js libraries is a difficult and significant work (and reusing the typescript stuff is highly non trivial, the type mismatch with OCaml is quite large)
<Drup>
Bluddy[m]: fair enough. Note that you could just try to use 4.02 ;)
<Algebr``>
Bluddy[m]: I have experience in both as an end user, I like BS more.
<Algebr``>
Drup: I am a little bit familiar with that process, yes.
<Drup>
(and honestly, some libraries are simply untypable)
<Algebr``>
also true
<Algebr``>
or too much mental hassle to type
<Drup>
It's acceptable in typedscript, because the idiom is "let's try to type as much as possible, and let's hope for the best, it's still better than javascript". That ... doesn't work as well in OCaml, where you are used to fully rely on the compiler for 95% of your safety.
shinnya has joined #ocaml
<Bluddy[m]>
BTW anyone have an opinion regarding the easiest way to produce a terminal application? Notty seems appealing.
<Algebr``>
notty or lambda-term
<Drup>
notty is better for visualisation, lambda-term is better for application
<Algebr``>
nottys example visualizations are AWESOME
<Drup>
(and lambda-term works on windows, which is ... impressive :D)
orbifx has quit [Quit: WeeChat 1.5]
<Bluddy[m]>
Drup: even without cygwin?
<Drup>
no idea
<Bluddy[m]>
notty's combinators are really nice
ousado has quit [Ping timeout: 260 seconds]
ousado has joined #ocaml
kakadu has quit [Remote host closed the connection]
Simn has quit [Quit: Leaving]
zpe has joined #ocaml
zpe has quit [Ping timeout: 258 seconds]
tmtwd has joined #ocaml
connorjacobsen has quit [Remote host closed the connection]
thizanne has quit [Ping timeout: 244 seconds]
Heasummn has joined #ocaml
connorjacobsen has joined #ocaml
connorjacobsen has quit [Ping timeout: 276 seconds]