<gour>
gasche: news clients are for posting to newsgroup which caml list on gmane is ;)
breakds has joined #ocaml
mort___ has quit [Quit: Leaving.]
_andre has joined #ocaml
csakatoku has quit [Remote host closed the connection]
<gasche>
mrvn: I like the subtle mix of Windows-95 borders and Debian logo
<gasche>
but it's not really representative of OCaml
<gasche>
(of course it could be superimposed on top of the code)
<mrvn>
gasche: That's qvwm.
<mrvn>
On Debian, note the swirl icon.
<gasche>
yep, that's the logo I was referring to
<mrvn>
and obviously you would have to superimposed on top of the code
<mrvn>
does janestreet have any screenshots of their trading software?
ontologiae has quit [Ping timeout: 256 seconds]
ygrek has quit [Ping timeout: 264 seconds]
<bernardofpc>
that they can publish ?
<mrvn>
obviously.
<bernardofpc>
gasche: why are the snippets from ocaml .org not ok ?
<bernardofpc>
(or Coq's code...)
<vbmithr>
hi
<vbmithr>
Is there a way in ocaml to get a functional value from a string ?
<vbmithr>
For example, I want to have a string representation of (fun _ -> true)
<mrvn>
an immutable string?
<vbmithr>
or any function
<vbmithr>
yeah
<vbmithr>
I want to persist a map datastructure
<vbmithr>
say from the Map module
<vbmithr>
that associate strings to a function of time
<vbmithr>
So I want to store functions in the map
<vbmithr>
and be able to represent it as a string (via sexplib or anything)
<mrvn>
a s-expression of the AST representing the function? I don't think sexplib does that.
<vbmithr>
yeah
<vbmithr>
it does not do that
<vbmithr>
I would be OK just to store the code of the function as a string
<vbmithr>
I tried with the Marshal module but it does not work either
<vbmithr>
I'm also fine with a datastructure that represent a function
<vbmithr>
basically I want to store the representation of a function of time
<vbmithr>
pure functions, not closures
Drup has joined #ocaml
<ggole>
No, functions are entirely abstract in OCaml
<ggole>
You can't even compare them.
<mrvn>
If you are doing bytecode then you can store the functions as string and eval them at runtime.
<gasche>
vbmithr: the type (foo -> bar) is a blackbox in functional languages
<ggole>
What would you do for an environment?
<gasche>
if you want to encode "transformation from foo to bar" in a way that allows later inspection, you should use your own AST to define your transformation language instead
<gasche>
for example, if your function is built from a list of (input, output) pair descriptions, you can use an association list instead
* ggole
mumbles something about Lisp
<gasche>
List.assoc is the "interpretation" function associates to each list its functional semantics/denotation
<mrvn>
it shouldn't be to hard to write a camlp4 module that creates a function_foo_ast value for each function_foo.
<gasche>
you mean each static function
<mrvn>
doing it for closures too might get tricky
<gasche>
even if you did that, you could not reconstruct general closures from their AST
<gasche>
so it's not going to work for serialization
<mrvn>
do you need reconstruction? The AST should be enough for equality.
<vbmithr>
environment ?
<gasche>
vbmithr: what are you trying to do?
<vbmithr>
gasche: yeah, I see
chambart has joined #ocaml
<vbmithr>
access control relative to time
<gasche>
mrvn: vbmithr was asking for persistence (..of the functions) earlier
<gasche>
I suppose your access control policies correspond to a description language that is better behaved than a functional type
<vbmithr>
a function that return when the day is monday, or false otherwise
<vbmithr>
that return true when…
<gasche>
are those policies meant to be written in OCaml code directly? do they come from a small set of policy combinators?
<vbmithr>
I think they can come from a set of policy combinators
<vbmithr>
I have not decided that, the simplest/cleanest will do.
<vbmithr>
Yeah, I'm going to do the combinators approach
<gasche>
I think having data instead of a function is cleaner
<gasche>
(not simpler at first, but will help a lot when you move to various kind of inspections/tooling/etc.)
<gasche>
also, writing an interpretation function policy -> (time -> bool), you will see optimization opportunities that you would probably have missed using functions from the start
<gasche>
eg. you can rewrite your combinator expressions to evaluate more efficiently
thomasga has joined #ocaml
niko has left #ocaml []
<rks`>
hmm gasche, I'm looking at P/Texp_override and despite Alain's documentation I don't understand where that comes from
<rks`>
(I could look at the parser ofc, but since you're here :-')
ollehar has quit [Ping timeout: 256 seconds]
<Drup>
gour: about the whole js spagetti to do a gui "web-app" on desktop with node-webkit, someone did that with eliom with "pure" ocaml. No js was involve (expect the generated one, by js_of_ocaml)
milosn has quit [Ping timeout: 264 seconds]
<gour>
Drup: hmm, never heard about Eliom, thanks for mentioning it...it sounds better...still i wonder about available 'widgets' 'cause my app would probably requie more than html5 only
<Kakadu>
Who have never heard about eliom?
<gasche>
rks`: well do you know the {< ... >} syntax in object-oriented OCaml?
<Drup>
Kakadu: some people, it seems :]
<gasche>
it returns a copy of the object with values modified as specified
<Drup>
gour: there is work to provide a widget library in eliom (or pure js_of_ocaml), there are two libraries, oj-widget and eliom-widget. Those are still in construction
<Drup>
gour: that's probably not a completely easy and well trace road, but that's definitly possible and doesn't involve that much silly javascript. You will probably need to read javascript documentation to write bindings if you need them, though.
<gasche>
I think the suggestions that were made earlier to separate the GUI part from the application backend make more sense, though
<gasche>
HTML+JS is clearly moving to be the dominant GUI paradox, but the capabilities to do that painlessly and portably are not well-established yet, I'd say, so it's better to keep your options
<Drup>
I agree with that, even if saying "let's separate the GUI from the backend" doesn't actually help you to choose a starting GUI library
<gasche>
well anyone he's already familiar with
<adrien_oww>
html+js
<adrien_oww>
so you can have the best of all wolrds
<Drup>
and the paradigm when doing html/js gui is quite different from regular GUI. It sounds difficult to be able to provide an abstraction that capture both
<adrien_oww>
worlds*
<adrien_oww>
high memory usage, memleaks, security issues, non-native appearance, high cpu usage
<adrien_oww>
and slow startup
<Drup>
:D
<Drup>
(adrien, the worst part is that I completely agree with you ..)
<gasche>
I think HTML+JS is already superior for a lot of data visualization tasks today
<gasche>
I'm not sure about GUI per se
<gasche>
but let's take an example
<gasche>
to my knowledge there is no good open-source software to visualize GPS traces from a hike
<gasche>
(I checked this summer)
<gasche>
if I were to write one in OCaml
<adrien_oww>
hmmm
<companion_cube>
isn't there one on open street map or something?
<adrien_oww>
nothing on the osm front?
<gasche>
I'd probably try to generate an HTML page using a fancy Javascript charting library
<companion_cube>
hi gasche btw
<adrien_oww>
gasche: it's *slow*
<gasche>
hm
<gasche>
I was unclear
<adrien_oww>
it's really slow
<adrien_oww>
look at the example charts
<gasche>
by visualization, I don't mean only seeing the trace on the map
<adrien_oww>
they're always very simple
<gasche>
I want a log of average speed over time, vertical speed, etc.
<gasche>
(for layering on a map, Viking does an okay-but-not-great job)
<adrien_oww>
I want to make something to draw a map from osm; but I'll do that with evas (from the EFLs) and there should be more than an order of magnitude in everything in favor of it
<gasche>
I'm more interested in the charting part
<ggole>
I've always felt that was missing from Unix
<ggole>
You should be able to pipe interesting data into a nice charting tool and munge it into the shape you want
<ggole>
But there's nothing.
<gasche>
are there good non-portable open source libs for that?
<ggole>
Python has a bunch of charting libraries.
<ggole>
Matplotlib and the like.
<Drup>
gasche: in js, d3
<ggole>
And various wrappers over, ie, Cairo.
<gasche>
Drup: yep, that's one choice
<Drup>
it's impossible to use
<gasche>
one problem with charting is that it's very easy to start wishing for animation
<adrien_oww>
I benched several libs
<adrien_oww>
gnuplot takes too much memory
<adrien_oww>
matplotlib is too slow
<adrien_oww>
look at vtk
<Drup>
adrien is too picky :D
<adrien_oww>
but it might be too powerful
<ggole>
gnuplot is pretty bad :(
<adrien_oww>
Drup: I made my own; I had to generate a .png through archimedes and display it in a lablgtk UI
<ggole>
But it's what I usually use.
<adrien_oww>
*that*
<adrien_oww>
was faster than others
<adrien_oww>
secret sauce? interval tree
<adrien_oww>
I'm sorry but what exists is pretty bad
<adrien_oww>
(well, Archimedes is pretty nice)
<Drup>
adrien : I'm not surprised. a hand-crafted solution is almost always better than everything else.
<Drup>
(at least, in this kind of field)
<gasche>
gnuplot is not really free software IIRC
<gasche>
ggole: I'm fine with gnuplot for charts for personal use
<gasche>
but imagine I'm trying to write a killer GPS-hike-visualization to renew OCaml's glory
<gasche>
I just cannot expose users to that
<ggole>
I've always found it quite painful.
<gasche>
well the simplest "write a bunch of floats there, get a curve" mode has a good benefit/cost ratio
<ggole>
Hard to get data into, hard to display what I want, hard to figure out how to tweak.
<adrien_oww>
Drup: I did the whole application in 3 days and there were other things to do too
<gasche>
as soon as you get outside that, forget it
<ggole>
That's not a very high bar.
<adrien_oww>
gasche: indeed, gnuplot is absolutely not gnu and not libre either
<ggole>
It would probably be easier to start a spreadsheet and just copy stuff in there, manually.
<ggole>
Ugh.
<adrien_oww>
Drup: and interval trees or anything to minimize memory usage and redraws is a bare minimum for plotting
<adrien_oww>
actually I forgot one good thing with Archimedes
<adrien_oww>
it doesn't plot more points than you have pixels
<adrien_oww>
yes, others do!
<adrien_oww>
they'll plot your 1M points on a 1k wide image
<adrien_oww>
(Archimedes samples and you can give it a function to decide how to sample; default is bisection)
<ggole>
Right, even if the points are displayed in ~5px circles
<ggole>
So there's ~4M pixels of overdraw.
<rks`>
thank you gasche
<rks`>
I didn't know about it
<adrien_oww>
I had to draw 24 hours of data from a dozen sensors which sampled at 1kHz or so
<adrien_oww>
and most of the time, the value stayed the same (sensors from cars; you don't brake 1000 times a second)
<gour>
Kakadu: see, see...some know about lablqt and not about Eliom :-)
<Kakadu>
gour: Eliom is really nice
<Kakadu>
gour: probably that potentially more nice then lablqt
<Kakadu>
:)
<Drup>
about the whole drawing/visualisation thingy, I have great hopes in vg/vz
BiDOrD has quit [Remote host closed the connection]
<Kakadu>
gour: Can u explain why generating some C++ code is so hard?
<Kakadu>
s/hard/unsuitable/
<gour>
Kakadu: not hard, maybe ugly
ontologiae has joined #ocaml
<gour>
Kakadu: i'd prefer not to see any C++ code when using lablqt
<Kakadu>
Then don't see. You really don't need to look at it
<adrien_oww>
gour: reading your comment on the wxwidgets bindings; would you say that lablgtk is a thick binding or not?
<gour>
adrien_oww: i'm not much familiar with it, but would tend to call it 'thick'
<gour>
do you agree?
<adrien_oww>
yeah, it is
<gour>
Kakadu: hmm...i'd have to try building the whole stuff then to see more clearly
<gour>
adrien_oww: i find it is a good sign for bindings in type-safe language like ocaml
<adrien_oww>
I'm trying to fight to misconceptions about lablgtk; first thing is to collect data, i.e. what people currently think :)
<adrien_oww>
(I think many people don't see it as thick)
<gour>
i believe it's not so easy to prove it...
talzeus has joined #ocaml
<gour>
if people have problem with the lack of docs, then it's very probable the bindings are thick...otherwise using plaing gtk docs would be sufficient to use thin bindings :-)
<Drup>
adrien : I already told you, but "ready to use" examples with nice abstractions in it would be insanely useful to make lablgtk easier to learn
talzeus__ has joined #ocaml
<gour>
adrien_oww: still, i stand with my proposal to put lablgtk into maint. mode and focus on qt bindings to make ocaml more attractive
<adrien_oww>
gour: yeah
<mathieui>
/W 10
<adrien_oww>
but actually, I read the tutorial again
<gour>
so many evolving languages trying to replace C++ providing only gtk bindings
<adrien_oww>
and there are too many pages
<adrien_oww>
ocaml and lablgtk makes the code so much shorter that you need to shorten the text around it too
<adrien_oww>
gour: I don't stand by you
<adrien_oww>
I dislike Qt; I dislike its auto-arrangement
<adrien_oww>
I dislike its build system
<gour>
pls. let me say: i always liked gtk look over qt and used gtk-based DEs (gnome and mostly xfce), but today i believe qt is premiere choice for gui toolkit
<adrien_oww>
I dislike its deep class hierarchy
<gour>
whatever, but gtk is dying...
<adrien_oww>
well, I'm not going to switch to Qt :)
<adrien_oww>
yeah, they gtk people are morons
<adrien_oww>
they couldn't do worse
<gasche>
GTK seems to be on the losing end of a popularity and liveness fight
<adrien_oww>
they crap windows support even though they only have to make a proper theme!
<gasche>
that said, it's unclear to me that Qt would be in any wait reinforced by this
<adrien_oww>
I'll rather move to the EFLs
<adrien_oww>
actually, I'm trying to but takes time
<gasche>
I'd rather plan that they'll both die to the benefit of lightweight mobilish interfaces
<gour>
adrien_oww: don't know what would e.g. Mac users say about EFL app running on their desktop :D
<gasche>
the OCaml community mostly ignored the problem of portability under Windows
<gasche>
it turns out that Windows seems to be dying faster than OCaml, so that wasn't such a bad choice
talzeus has quit [Ping timeout: 248 seconds]
<gasche>
maybe we'll survive to desktop GUI as well?
<gour>
gasche: something like python's kivy?
<adrien_oww>
gour: you can theme EFLs well
<gasche>
gour: I didn't know about kivy before your message
<adrien_oww>
gasche: hmmmmmmmmmmmmmm
<gasche>
that's one of the troubling things with the new kids: there are so many of them
<gasche>
adrien_oww: I do respect people that fight to live by the old ways :-'
<adrien_oww>
I'm not sure Windows is going to die that quickly
<ggole>
Windows isn't dying (sadly). It's just a bit more zombie like every year.
<gasche>
we should have a Rashomon poster with Adrien as Windows+GTK guru
<gour>
0install author (rewriting it in ocaml) writes: "OCaml is actually a pretty small language. Once you’ve read the short tutorials you know most of the language." what do you think about it?
<gasche>
gour: I think it's not exactly true, but it is true that OCaml has a nice, small subset that you can live in
<Drup>
gour: it didn't try to do functor spagetti yet :]
<Drup>
he*
<Kakadu>
I have heard that many times
<Kakadu>
gour^^
<adrien_oww>
you can go deeper but you can do most things after only a few hours of learning
<ggole>
The "core ML" bit of OCaml is pretty small and tidy.
<gasche>
compared to C++, it is possible to not be bitten by say, Objects, if you don't use them
<gasche>
I think Scala also has such abstraction leaks (you cannot really ignore the problems of type inference)
<adrien_oww>
gasche: :blink:
<Drup>
gour: I know, I read it
<gour>
ahh,ok. ;)
<Drup>
gour: but that's not spagetti yet, it's quite small
<ggole>
When I first started learning OCaml, I was somewhat taken aback that not a single object was defined by the standard library.
<gour>
how do you like upcoming ocmal book?
<ggole>
But that was probably a good decision. It means you can just ignore them.
<ggole>
(Unlike monads, *cough*.)
<Drup>
gour: but this series of article is very interesting as a learning viewpoint to ocaml. The author is not really an average programmer, though.
<gour>
Drup: you mean 'average FP programmer' or in general?
<Drup>
in general
<gour>
:-)
<Drup>
you don't find a lot of people that, when they are learning ocaml (and don't come from haskell) say "there is no existential types" (well, it's false now, but you get the point).
<gour>
yep
<gasche>
I think that the series should not be taken too far as a general tool for advertising to potential beginners
<gasche>
the author cared about some fairly specialized points that were essential to his needs
<gasche>
(also I think that Haskell was dismissed too quickly, but well)
<gour>
i'm also not an average programmer :D
maufred_ has joined #ocaml
Sim_n has joined #ocaml
<gour>
i believe that ocaml could make some simple things simpler and that's it comparing to haskell, imho
<gour>
but although being under-average programmer, it hurts to be forced to use python and write unit-tests for writing common gui app :-/
Simn has quit [Ping timeout: 245 seconds]
<companion_cube>
type foo = { bar : 'a . 'a -> foo; } ;; <--- this isn't an existential type?
<Drup>
companion_cube: type bla = Blo : 'a -> bla
maufred has quit [Ping timeout: 264 seconds]
<companion_cube>
hmmmm
thomasga has quit [Ping timeout: 260 seconds]
chambart has quit [Ping timeout: 245 seconds]
<gasche>
companion_cube: yours is an universal type
<gasche>
but you can get an existential by double-wrapping in an ugly way
<companion_cube>
ok
<companion_cube>
I mean, it can occur in a negative position
<companion_cube>
but I guess the difference is that I can apply foo.bar to any type, whereas the GADT prevents from applying to any type (but the existentially quantified one)
ttamttam1 has quit [Quit: ttamttam1]
csakatoku has joined #ocaml
ollehar has joined #ocaml
n06rin has joined #ocaml
csakatoku has quit [Remote host closed the connection]
gour has quit [Disconnected by services]
gour_ has joined #ocaml
dsheets has joined #ocaml
<Kakadu>
about opam files for packages
<Kakadu>
it seems I can't write "cd" in build order
<Kakadu>
is it forbidden or not implemented?
<rixed>
Kakadu: as far as I know you can use whatever shell command you like
<Kakadu>
The problem is that I have makefile not in root directory of project and I need to write dummy scripts which make cd and run something
<rixed>
shouldn't be a problem
<Kakadu>
rixed: Yeah, but 'cd' is not an executable, it is bash command
<Kakadu>
I mean `which cd` returns nothing
<rixed>
Kakadu: "each line contains the shell commands corresponding to a string list." Opam manual
<rixed>
I understand this as : each line is executed via system() (ie. given to a shell to parse and exec)
<rixed>
Hum, can't find an exemple of this.
<rixed>
Kakadu: you migh be right after all.
<rixed>
Kakadu: then, you must rely on 'make -C subdir'
<rixed>
Kakadu: or calling '/bin/sh -c "whatever"' yourself
<rixed>
Kakadu: of course this would not be considered portable :)
<Kakadu>
Yeah, it is a good idea, thanks
<rixed>
Kakadu: portable nor secure
<Drup>
Kakadu: place a makefile in the main directory that call the sub makefile ?
<Drup>
it seems far more simple to me
<rixed>
Drup: 'make -C' is quite simple too
<Drup>
probably, I think it's the same.
<jpdeplaix>
is there an official git repository for menhir somewhere ?
<Kakadu>
okay, It seems I can't get rid of /bin/sh -c "whatever"
thomasga has joined #ocaml
<Kakadu>
because I have file "qml/configure" which needed to be executed in a proper PWD
<ggole>
cd can't be an executable, for what should be obvious reasons
<Kakadu>
Heh, everything is more bad that I thought
<whitequark>
(and several dozens of files that one depends upon. I'm not exactly a fan of this project structure but that's what I have.)
Sim_n is now known as Simn
Kakadu has quit []
ygrek has quit [Ping timeout: 264 seconds]
csakatoku has joined #ocaml
ihm1 has joined #ocaml
pratz has joined #ocaml
thomasga has quit [Quit: Leaving.]
pratz has left #ocaml []
yacks has quit [Quit: Leaving]
caseyjames has joined #ocaml
ontologiae has joined #ocaml
<caseyjames>
If I have two lists A and B, how can I return a list of the nearest B index to every A value?
<caseyjames>
or rather the B index of the B value nearest the A value
weie has quit [Quit: Leaving...]
Yoric has joined #ocaml
yacks has joined #ocaml
wagle has joined #ocaml
shinnya has quit [Ping timeout: 276 seconds]
Yoric has quit [Ping timeout: 264 seconds]
skchrko has quit [Quit: Leaving]
Drup has quit [Ping timeout: 240 seconds]
caseyjames has quit [Ping timeout: 250 seconds]
Kakadu has joined #ocaml
efforeffort has joined #ocaml
darkf has joined #ocaml
asmanur has quit [Ping timeout: 245 seconds]
walter has quit [Quit: This computer has gone to sleep]
efforeffort has left #ocaml []
ben_zen has quit [Quit: Wheee]
skchrko has joined #ocaml
varnie has left #ocaml []
<Kakadu>
guys, what `repository` means in opam context?
<Kakadu>
is it equal `remote` concept?
<Kakadu>
Yeah, it seems so
<Kakadu>
Than `opam update name` should update a specific remote repository but on my machine it gives error: `name` is not a a valid versioned package name
<Kakadu>
opam version 1.1.0
<Kakadu>
can u check?
derek_c has joined #ocaml
<wmeyer>
Hi Kakadu, repository is the same as remote in git
<wmeyer>
yes, it's the same as remote
mapour has joined #ocaml
<dsheets>
fwiw, my understanding is that 'repository' is the actual file system structure wherever it is and 'remote' is opam's internal named pointer to such a structure
<wmeyer>
hence the change in the namimg I think
snearch has joined #ocaml
ihm1 has quit [Quit: ihm1]
ousado has quit [Read error: Operation timed out]
ontologiae has quit [Ping timeout: 248 seconds]
ousado has joined #ocaml
snearch has quit [Quit: Verlassend]
derek_c has quit [Ping timeout: 245 seconds]
mort___ has joined #ocaml
csakatoku has quit [Remote host closed the connection]
Yoric has joined #ocaml
ggole has quit []
<chris2>
did anyone ever consider making ocamlbuild generate a makefile for faster recompilation?
<Kakadu>
This J.Harrop such a troll
<Kakadu>
I think that his messages in caml-list should be ignored
<chris2>
is that a reply to my question?
<Kakadu>
no
<chris2>
ok :)
<Kakadu>
:)
<Kakadu>
btw, what features of gnumake will increase compilation speed?
<Kakadu>
I only can think -jN
<chris2>
not having to scan all files?
<Kakadu>
it scans everything and compares last modify time
<chris2>
hm
<Kakadu>
chris2: Am I mistaken?
<chris2>
i'm not totally sure
<chris2>
but it would make sense
<chris2>
the bottleneck in my builds is "open Core.Std" :P
<chris2>
4.98 0.027115 46 592 getdents
<chris2>
looks like it
<adrien>
chris2: what you mentioned is actually (under another form) under discussion
snearch has joined #ocaml
<adrien>
it's basically not recomputing the deps on each run
<chris2>
ok
<adrien>
Kakadu: yes he is
zpe has quit [Remote host closed the connection]
<Kakadu>
adrien: :)
<Kakadu>
After his message I was wondering if somebody will take him seriously....
<Kakadu>
It seems that have happend
<companion_cube>
he is a well-known troll
<companion_cube>
in both the haskell and ocaml communities
Neros has quit [Read error: Connection reset by peer]
yacks has quit [Quit: Leaving]
ben_zen has joined #ocaml
bondar has quit []
mort___ has quit [Quit: Leaving.]
csakatoku has joined #ocaml
derek_c has joined #ocaml
Simn has quit [Quit: Leaving]
<gour>
he is 'well-known' F# evangelist leading that xyzfrog company?
<Kakadu>
flyingfrog
<gour>
right
<adrien>
F# evangelist
<adrien>
well
<adrien>
depends on the day
<adrien>
I think that on month days that are even, he's an F# evangelist
<adrien>
those divisible by 3, he'll state Haskell is superior to OCaml in some regard
<adrien>
thos divisible by 5, he'll start OCaml is superior to Haskell in some regard
<gour>
doesn't he make some real GBPs with f3?
<tane>
adrien, what happens on the 15th?
<adrien>
those divisible by 15, he'll state everything and its opposite
<tane>
haha, thanks :)
<adrien>
gour: that's what he said at some point; but he's capable of saying everything
<adrien>
I won't answer his last message; I don't do OpenGL myself but I don't know many people who do and who believe it's a good fit for 2D graphics
csakatoku has quit [Ping timeout: 248 seconds]
<gour>
yeah, too low-level
asmanur has joined #ocaml
<gour>
Kakadu: have you seen comment from Fabrice on the blog about Qt bindings?
<triyo>
I'm new to ocaml dev and I've been setup my emacs with utop. I get the following error during emacs load: "Wrong type argument: listp, CAML_LD_LIBRARY_PATH=/valid/path/to/stublibs"
snearch has quit [Quit: Verlassend]
<triyo>
would this be some sort of version issue?
rwmjones has quit [Read error: Operation timed out]
<triyo>
It seems to be the following elisp line that causes the problem to occur: "(dolist (var (car (read-from-string (shell-command-to-string "opam config env --sexp")))) (setenv (car var) (cadr var)))"
<triyo>
Firstly, there doesn't seem to be a "--sexp" flag in my version of opam, as far as I can tell at least
<triyo>
So I removed that flag
derek_c has quit [Quit: leaving]
<ollehar>
can I use phantom types with recursion in some way?
tani has joined #ocaml
tane has quit [Ping timeout: 241 seconds]
_andre has quit [Quit: leaving]
yacks has joined #ocaml
thomasga has joined #ocaml
rwmjones has joined #ocaml
mort___ has joined #ocaml
es917 has joined #ocaml
Neros has joined #ocaml
<ollehar>
i.e., I want the type system to count the recursions.
<adrien>
I think you can find something on the internet about that
<ollehar>
adrien: one of these "ungooglable" things :P
thomasga has quit [Quit: Leaving.]
<adrien>
you only need to trigger gasche actually :P
<ollehar>
adrien: yeah
<ollehar>
adrien: might wright a gashe-specific stackoverflow question
<ollehar>
although I know the answer: "use coq", which I'm also trying to learn.
<asmanur>
ollehar: well you can do it but as always, manipulating integers at the type level is hard
Yoric has quit [Ping timeout: 264 seconds]
<ollehar>
asmanur: I guess I have to know the number of recursions beforehand, right?
Neros has quit [Read error: Connection reset by peer]
<ollehar>
and then it will become an "in-code static proof"...
<asmanur>
ollehar: i'm not sure to understand
<asmanur>
I believe that what you are describing is similar to the construction that turns a list ('a list) to a vector (('a, n) vector) where the type becomes indexed by the length (= the number of recursion) of the object
Neros has joined #ocaml
Anarchos has joined #ocaml
<ollehar>
asmanur: hm, yes.
<ollehar>
the application at hand regards a lua state, and the stack that works as communication between lua and ocaml.
<Anarchos>
ocamldebug just works on Haiku, hey that's cool !
triyo has quit [Quit: triyo]
<asmanur>
so it is possible to track the number of iterations but you will not be able to handle it in a first-class way
<ollehar>
asmanur: you mean at value level, but not type level?
<asmanur>
yes
<asmanur>
for that you need the power of dependant types :-°
<ollehar>
hm
<asmanur>
so basically you will only be able to check for increments and equality, things like that
gour has quit [Quit: WeeChat 0.4.1]
tani has quit [Quit: Verlassend]
<Anarchos>
i read an interesting article saying that in presence of references, typing is semidecidable. Anybody ever read that ? I forgot the link
<asmanur>
what do you mean "typing" ?
<mrvn>
that's where the value restriction comes in and such stuff
<Anarchos>
"type inference"
mort___ has quit [Quit: Leaving.]
<asmanur>
Anarchos: it's weird because i can't see how you can make ocaml loop on code with only references
<Anarchos>
asmanur let me look for it then
zpe has joined #ocaml
csakatoku has joined #ocaml
<ollehar>
asmanur: I don't know if its possible to turn a list into a type-level vector with length. only the other way around? otherwise you will get existential types, something something...
<Anarchos>
asmanur there was even an example
<asmanur>
ollehar: yes that is right
pippijn has quit [Read error: error:1408F10B:SSL routines:SSL3_GET_RECORD:wrong version number]
pippijn has joined #ocaml
zpe has quit [Ping timeout: 245 seconds]
<Anarchos>
asmanur i can't find it anymore, but i guess it was a comment on lambda-the-ultimate
csakatoku has quit [Ping timeout: 245 seconds]
Snark has quit [Quit: leaving]
<asmanur>
Anarchos: since ML+ref is unsound, you need to specify how you restrict yoursef to a sound subset, and for the subset implemented in ML there is a clear terminating algorithm I believe
<Anarchos>
asmanur yes i was referring to that property of ML+ref. Any doc about it ?
<asmanur>
being unsound ?
<companion_cube>
what do you mean it's unsound?!!
<asmanur>
you can write a function 'a -> 'b without using any unsafe features
<companion_cube>
asmanur: how?
<companion_cube>
(I mean, even with the restriction on the type of ref?)
<asmanur>
we're talking about ML+ref without restriction here
<def-lkb>
companion_cube: type of references are not generalized in ocaml
<asmanur>
(well, at least I am)
<companion_cube>
ahhh, ok
Anarchos has quit [Quit: sigkill me -SLEEP]
<companion_cube>
I thought it was obvious the restriction was needed :D
djcoin has quit [Quit: WeeChat 0.4.0]
Kakadu has quit []
zxqdms has joined #ocaml
zxqdms has quit [Client Quit]
zxqdms has joined #ocaml
Drup has joined #ocaml
Yoric has joined #ocaml
csakatoku has joined #ocaml
csakatoku has quit [Ping timeout: 256 seconds]
ollehar has quit [Ping timeout: 260 seconds]
Yoric has quit [Ping timeout: 245 seconds]
skchrko has quit [Ping timeout: 248 seconds]
zarul has quit [Ping timeout: 256 seconds]
zarul has joined #ocaml
ollehar has joined #ocaml
ihm1 has joined #ocaml
transfinite has quit [Ping timeout: 268 seconds]
ontologiae has joined #ocaml
Nahra has quit [Ping timeout: 256 seconds]
ihm1 has quit [Read error: Connection reset by peer]
ihm1_ has joined #ocaml
ben_zen has quit [Ping timeout: 245 seconds]
mfp has quit [Ping timeout: 245 seconds]
ihm1_ has quit [Read error: Connection reset by peer]