<whitequark>
is there a quasiquotation preprocessor somewhere for ocaml strings
<whitequark>
?
<whitequark>
oh, I just realized that this won't really be possible :/
Drup has quit [Quit: Leaving.]
pkrnj has quit [Quit: Computer has gone to sleep.]
pkrnj has joined #ocaml
introom has joined #ocaml
csakatoku has joined #ocaml
ollehar has joined #ocaml
q66 has quit [Quit: Leaving]
csakatoku has quit [Ping timeout: 276 seconds]
madroach has quit [Ping timeout: 264 seconds]
madroach has joined #ocaml
wwilly has joined #ocaml
wwilly has quit [Client Quit]
mfp has quit [Ping timeout: 264 seconds]
walter has joined #ocaml
darkf has joined #ocaml
Harzilein has joined #ocaml
levi has joined #ocaml
levi has quit [Read error: Connection reset by peer]
levi has joined #ocaml
levi has quit [Read error: Connection reset by peer]
levi has joined #ocaml
ben_zen has joined #ocaml
levi has quit [Read error: Connection reset by peer]
levi has joined #ocaml
levi has quit [Read error: Connection reset by peer]
levi has joined #ocaml
introom has quit [Remote host closed the connection]
levi has quit [Read error: Connection reset by peer]
csakatoku has joined #ocaml
ollehar has quit [Ping timeout: 240 seconds]
walter has quit [Quit: This computer has gone to sleep]
walter has joined #ocaml
introom has joined #ocaml
walter has quit [Quit: This computer has gone to sleep]
pkrnj has quit [Quit: Computer has gone to sleep.]
introom has quit [Remote host closed the connection]
alex-hu has quit [Remote host closed the connection]
introom has joined #ocaml
Neros has quit [Ping timeout: 260 seconds]
ollehar has joined #ocaml
levi has joined #ocaml
ggole has joined #ocaml
pkrnj has joined #ocaml
chambart has quit [Ping timeout: 246 seconds]
chambart has joined #ocaml
shinnya has quit [Ping timeout: 260 seconds]
chambart has quit [Ping timeout: 246 seconds]
Kakadu has joined #ocaml
Snark has joined #ocaml
avsm has quit [Ping timeout: 248 seconds]
pango_ has quit [Remote host closed the connection]
pkrnj has quit [Quit: Computer has gone to sleep.]
mcclurmc has joined #ocaml
mcclurmc has quit [Quit: Leaving.]
Simn has joined #ocaml
<whitequark>
ocaml in debian is horribly outdated :/
<whitequark>
3.12.1 still
<whitequark>
annnd llvm in opam is horribly outdated too!
<whitequark>
awesome
<ggole>
Outdated bindings? :o
* ggole
shocked, shocked
* whitequark
giggles
<whitequark>
well, it's 3.2, so it is not exactly ancient
<whitequark>
but 3.3 has some bugfixes I need.
<ggole>
That's always uncomfortable.
<adrien>
3.3 got out only weeks ago iirc
* whitequark
nods
<adrien>
but the main issue is probably that llvm devs don't make point releaes for bugfixes
<whitequark>
adrien: I'm pretty sure that ocaml bindings are maintained in the LLVM tree, so it shouldn't be problematic to update the bindings.
<adrien>
hmmm, not sure about that
<whitequark>
that's why I'm surprised: it is (likely) is as complex as a git pull.
<adrien>
also, it's bad to do that imho
<adrien>
cairo bindings are in-tree and completely stalled
gautamc has quit [Read error: Connection reset by peer]
<ggole>
They probably simply haven't been packaged for opam (yet), if so
<whitequark>
LLVM is quite a moving target, so I'd rather have those folks maintain them
<adrien>
how would one become the new maintainer for them? integrate into the cairo team and that's definitely intimidating
<whitequark>
against bit-rot at least
<adrien>
much easier to have your own repo where you can push the 3 or 4 years of maintenance that is needed
<whitequark>
adrien: well, the bindings are indeed written "on demand". want some feature? send a patch to LLVM
<adrien>
it doesn't prevent bitrot if nobody builds the bindings
<whitequark>
but the root of the problem is that they depend on LLVM C API
<adrien>
cairo2 (bindings) are on the forge and, these, are up-to-date
<whitequark>
and the C API is written "on demand" too
<whitequark>
so you would often write first the C binding, get a patch accepted, then OCaml binding
gautamc has joined #ocaml
<ggole>
That's always gonna be trailing edge
<adrien>
yes, if you need to have changes to the C API
<whitequark>
it's not a good solution, because the C API sort of sucks, but I see why it works as it does
<whitequark>
ggole: indeed.
<adrien>
but for other cases, I'm really not convinced
* whitequark
sighs
<whitequark>
now opam is compiling LLVM. I wonder how big a chunk of my life can be described with "compiling LLVM".
<ggole>
That's one of the downsides of C++.
<adrien>
ever built webkit?
<whitequark>
no, but I talked with a guy who built webkit with LTO
joostvb has quit [Ping timeout: 264 seconds]
<adrien>
probably even more awful
<whitequark>
it took him 8 hours on a 12-core overclocked i7 with 32G of RAM
<adrien>
anyway, llvm is > 2 hours on my machine
<whitequark>
llvm without clang is 6 minutes on my notebook
<whitequark>
for X86+ARM
<adrien>
it's a fairly small machine but even on a bigger machine it should be fairly long
<adrien>
hmmm, that sounds weird to me
<adrien>
well, been some time since I last built it
<whitequark>
it's a debug build, hence, not optimized very much
<ggole>
Clang includes lots of static analysis stuff as well as the C/C++ front ends?
<whitequark>
release builds take longer.
<whitequark>
ggole: define "static analysis"
<whitequark>
there's clang-analyzer, but it is fairly simple and benign
<whitequark>
most time is indeed taken by the frontend; C++ frontends are enormous beasts
<ggole>
Hmm, I thought it was fairly extensive
<ggole>
Right
<whitequark>
well, compared to the frontend.
<whitequark>
the most annoying part is when something like opam wants to compile all backends.
<whitequark>
you see, apart from C++ in general, LLVM likes to compile generated tables which span literally megabytes of compiled code
<whitequark>
(or used to; I think they optimized x86 to 200k or so, which is still enormous)
<ggole>
Hmm. DAG matchers and stuff like that.
* whitequark
nods
<whitequark>
tblgen in general.
<ggole>
It's the sane way to do it.
<ggole>
(In C++, anyway.)
<whitequark>
sure
<whitequark>
much better than template metaprogramming
<ggole>
What isn't? -_-
<whitequark>
the saddest part of all, 60-80% of compilation time is spent in the C++ frontend continously re-reading the same code.
<whitequark>
this is just depressing.
<ggole>
That's C++ for you.
<ggole>
A compilation model based on repeated textual inclusion, plus a programming model that pushes more code into headers.
<whitequark>
yes and no
<whitequark>
you know about the export keyword?
<ggole>
Does clang implement it properly?
<whitequark>
no, and it in fact got ripped from the standard
<whitequark>
the reasoning is twofold
<ggole>
Because nobody would implement it.
<ggole>
(Other than that one bunch of guys.)
<whitequark>
first, turns out it's incredibly complex to implement. it took EDG two years and they slipped the schedule first time ever.
<whitequark>
but more interestingly, second, it doesn't really give you any advantage
<whitequark>
because, I guess, reasons. I don't quite understand why, but I trust EDG to know their shit
<ggole>
I'
<ggole>
ve heard that too.
<ggole>
Not sure why.
<ggole>
Precompiled headers seem to be the next push forward on compilation speed.
<whitequark>
yup, and clang has a very good PCH engine
<whitequark>
but frankly, PCH is dumb
<ggole>
Sure: it's a silly hack instead of a nice well engineered thing.
<whitequark>
it's a way of saying "we can't do language design"
Neros has joined #ocaml
mcclurmc has joined #ocaml
<ggole>
That's what you get when you bolt old shit together without thinking it through.
<whitequark>
I think C/C++ even got the distinctive translation units for making it faster
<whitequark>
but isn't the C++ repeated parsing plus linking time eat any possible benefit back several times?
<ggole>
Benefit from what, separate compilation?
* whitequark
nods
<whitequark>
I can get it when it's C and you have 640K of RAM
<whitequark>
but not when your linker can only work on 64-bit machines because you have so much goddamn symbols you exhaust the 32-bit address space
joostvb has joined #ocaml
<ggole>
Dunno: people did distribute .a files a lot, and that probably saved a lot of work over using source.
joostvb is now known as Guest9572
<ggole>
C++ makes that worse too, with mangling.
<whitequark>
(fun fact: LLVM can't be compiled as a dll with mingw: you hit some hardcoded limit on the symbol count and it dies.)
<ggole>
Awesome.
<whitequark>
it's a contrived combination of C++ and bug in old binutils version
* whitequark
shrugs
<whitequark>
(.a files) well, I'm not suggesting to kill all separate compilation
<whitequark>
more like, cat `find . -name *.cpp` | g++
<ggole>
There's still benefit in that when you are developing the source.
Neros has quit [Ping timeout: 248 seconds]
<ggole>
If you are hacking on one .cpp, you only pay for compiling that + its headers + linking.
<whitequark>
right.
<ggole>
Not sure if it's any faster for a full compile.
<whitequark>
well, if PCH are any faster, then this will be at least as fast
<ggole>
But every large project runs into serious pain, so it's not like the current scheme is fantastic.
* whitequark
nods
<whitequark>
I think you could fix the "one .cpp" problem like this:
<whitequark>
for each data type, calculate a checksum of its contents, and compose a dependency graph between types, then store it somewhere and invalidate when newly parsed stuff differs from what you have.
<whitequark>
I believe this is already implemented in some form of another under the name of "incremental compilation", so it's not like it is very hard.
<ggole>
Hmm...
<ggole>
Seems you would replace a .o for each file with a .compile for everything
<ggole>
(Including headers.)
<whitequark>
yep
<whitequark>
well, there would be no real distinction between headers, nor #include for that matter
ben_zen has quit [Ping timeout: 240 seconds]
<whitequark>
(maybe for ordering the headers themselves, since macros would be depend on that, but that's about it)
shinnya has joined #ocaml
Guest9572 has quit [Ping timeout: 246 seconds]
mcclurmc has quit [Ping timeout: 276 seconds]
joostvb_ has joined #ocaml
mcclurmc has joined #ocaml
Neros has joined #ocaml
introom has quit [Remote host closed the connection]
introom has joined #ocaml
introom has quit [Ping timeout: 246 seconds]
mcclurmc has quit [Quit: Leaving.]
avsm has joined #ocaml
milosn has joined #ocaml
osa1 has joined #ocaml
mort___ has joined #ocaml
q66 has joined #ocaml
avsm has quit [Quit: Leaving.]
Neros has quit [Read error: Operation timed out]
csakatoku has quit [Remote host closed the connection]
mfp has joined #ocaml
mort___ has quit [Ping timeout: 276 seconds]
tane has joined #ocaml
troydm has quit [Ping timeout: 264 seconds]
contempt has quit [Ping timeout: 264 seconds]
contempt has joined #ocaml
iZsh has quit [Excess Flood]
iZsh has joined #ocaml
contempt has quit [Ping timeout: 240 seconds]
contempt has joined #ocaml
csakatoku has joined #ocaml
introom has joined #ocaml
csakatoku has quit [Ping timeout: 240 seconds]
mcclurmc has joined #ocaml
malo has joined #ocaml
mcclurmc has quit [Quit: Leaving.]
introom has quit [Remote host closed the connection]
introom has joined #ocaml
pango has joined #ocaml
Drup has joined #ocaml
ousado_ has joined #ocaml
dtg has joined #ocaml
malo_ has joined #ocaml
BiDOrD has joined #ocaml
malo has quit [Ping timeout: 246 seconds]
Myk267 has quit [Ping timeout: 246 seconds]
ousado has quit [Ping timeout: 246 seconds]
dtg_ has quit [Ping timeout: 246 seconds]
BiDOrD_ has quit [Ping timeout: 246 seconds]
Myk267 has joined #ocaml
Kakadu has quit [Read error: Operation timed out]
ousado_ is now known as ousado
ousado has quit [Changing host]
ousado has joined #ocaml
itewsh has joined #ocaml
watermind has joined #ocaml
<watermind>
question about matching
<watermind>
suppose I have a record with two variants
<watermind>
so a pair of co-pairs
<watermind>
how are we supposed to define a match statement for it?
<watermind>
so a possibility is to perform two projections, get both co-pairs and then use nested match statements
<watermind>
but that seems like overkill
<watermind>
ideally one would just match it like... match p with {A ; C} -> ... | {B;C} -> ... | {A ; D} -> ... | {B;D} -> ...
<watermind>
but that appears to be wrong, seems like I can only use multiple cases within a match when matching a variant
<watermind>
so how do you usally do this?
<def-lkb_>
not sure I understand what you are asking for, but what about
<Drup>
watermind: match p with { bla = A ; blu = B }
<def-lkb_>
type r { a = [`A|`B]; b = [`C|`D] }; match r with { a = `A; b = `C } -> _ | …
<def-lkb_>
:'
mort___ has joined #ocaml
mort___ has quit [Ping timeout: 276 seconds]
introom has quit [Remote host closed the connection]
Sim_n has joined #ocaml
Simn has quit [Ping timeout: 240 seconds]
<watermind>
Drup: def-lkb_: weird that wasn't working for me
<Drup>
watermind: well, you didn't use the right syntax.
chambart has joined #ocaml
<watermind>
Drup:
<watermind>
Drup: I deleted it meanwhile... I suspect I may have sued extra ;;
<watermind>
at the end of each matching statment
introom has joined #ocaml
<ggole>
watermind: match p with {A ; C} just doesn't work. Record elements are named, not positional.
Yonex has joined #ocaml
ben_zen has joined #ocaml
Kakadu has joined #ocaml
Kakadu has quit []
<watermind>
ggole: I see, I thought maybe you could use both, much like in functions with named arguments
<ggole>
Inference couldn't really work with just positions.
ben_zen has quit [Ping timeout: 264 seconds]
<adrien>
I think I've seen svn branches around tha
<adrien>
t
<adrien>
but that also means that it needed a substantial amount of changes
<pippijn>
I want: type t = A of { foo : int; bar : string; } | B of { foo : string; bar : int; }
ygrek has joined #ocaml
<adrien>
there's a branch for that!
<adrien>
</Steve>
<adrien>
(or at least a PR)
<pippijn>
adrien: with locally scoped record field names?
<pippijn>
so A and B can both have a record field named "foo"?
<pippijn>
because if not, that's next to useless
watermind has quit [Quit: Konversation terminated!]
<adrien>
I'm pretty sure there's something close to that
ygrek has quit [Ping timeout: 240 seconds]
ollehar has quit [Ping timeout: 248 seconds]
travisbrady has joined #ocaml
malo_ has quit [Ping timeout: 260 seconds]
itewsh has quit [Quit: o/]
travisbrady has quit [Quit: travisbrady]
travisbrady has joined #ocaml
tane has quit [Quit: Verlassend]
iZsh has quit [Quit: Coyote finally caught me]
iZsh has joined #ocaml
iZsh has quit [Excess Flood]
iZsh has joined #ocaml
chambart has quit [Ping timeout: 246 seconds]
vpm has quit [Ping timeout: 245 seconds]
vpm has joined #ocaml
introom has quit [Remote host closed the connection]
travisbrady has quit [Quit: travisbrady]
malo has joined #ocaml
malo has quit [Ping timeout: 248 seconds]
malo has joined #ocaml
mcclurmc has joined #ocaml
darkf has quit [Quit: Leaving]
malo has quit [Ping timeout: 264 seconds]
introom has joined #ocaml
mcclurmc has quit [Ping timeout: 248 seconds]
malo has joined #ocaml
mcclurmc has joined #ocaml
introom has quit [Ping timeout: 248 seconds]
mcclurmc has quit [Quit: Leaving.]
Drup has quit [Ping timeout: 256 seconds]
beginner42 has joined #ocaml
<beginner42>
i have started an oasis project with oasis quickstart, but how can i add now files to the _oasis file without doing it manually? is there some simpler way?
ulfdoz has joined #ocaml
ggole has quit []
tane has joined #ocaml
beginner42 has quit [Quit: irc2go]
troydm has joined #ocaml
avsm has joined #ocaml
avsm has quit [Quit: Leaving.]
avsm has joined #ocaml
wormphlegm has quit [Quit: leaving]
Drup has joined #ocaml
chambart has joined #ocaml
wormphlegm has joined #ocaml
avsm has quit [Quit: Leaving.]
wormphlegm has quit [Client Quit]
wormphlegm has joined #ocaml
wormphlegm has quit [Quit: leaving]
wormphlegm has joined #ocaml
tani has joined #ocaml
gautamc has quit [Read error: Connection reset by peer]
tane has quit [Ping timeout: 248 seconds]
gautamc has joined #ocaml
avsm has joined #ocaml
pkrnj has joined #ocaml
avsm has quit [Ping timeout: 264 seconds]
cdidd has quit [Remote host closed the connection]
walter has joined #ocaml
cdidd has joined #ocaml
walter has quit [Quit: This computer has gone to sleep]
beginner42 has joined #ocaml
<beginner42>
can oasis generate a makefile inside the src folder, i found a few projects where this seemed to have happend
<beginner42>
?
<beginner42>
ls
<mrvn>
run it inside the src folder
<beginner42>
mrvn: what command are you referring to?
<mrvn>
oasis
<beginner42>
mrvn: just oasis?
Snark has quit [Quit: leaving]
<mrvn>
if you run oasis inside src you will have to run everything else there too
<beginner42>
mrvn: for example in this project, this makefile is inside the src folder and seems to be generated
<mrvn>
maybe a leftover from before oasis was used?
<beginner42>
mrvn: maybe? i just get started with oasis and interfacing with c functions, so i am trying to learn from other examples
<dsheets>
beginner42, is your binding performance-critical?
avsm has joined #ocaml
avsm has quit [Ping timeout: 256 seconds]
ulfdoz has quit [Ping timeout: 264 seconds]
Neros has joined #ocaml
<beginner42>
dsheets: i am working on a binding for the zmq version 3.3. guess performance is critical there
<dsheets>
beginner42, ok. I'm interested in using it. Will it be open source?
<beginner42>
dsheets: if it works for sure
<dsheets>
beginner42, cool. It is easy to get tripped up when writing bindings with the C macros. If you want to bootstrap your implementation, you might gives ctypes a gander.
<dsheets>
right now, you will suffer a performance hit like 10x but that margin should drop to near 1x with new improvements coming in ctypes 0.2 and ctypes 0.3
<beginner42>
dsheets: its a nice feeling when for the first time the c function returns an value :) i try to get familiar with c interface before i get started with ctypes, but i ll keep it in mind
<dsheets>
with ctypes, you don't need to know ocaml's c interface at all (beyond the types of the code you are binding). It makes the time-to-stable-functionality very short
<dsheets>
without requiring grokking the gc and nuances of internal representations
<beginner42>
dsheets: i sounds really nice, but for one part i am very curious about learning to write interfaces directly to c and then its the performance part you just mentioned
<dsheets>
sure, i understand. If you can wait about 2 months, ctypes will allow static generation of that very same stub code that you would now write (error-prone) by hand
<dsheets>
with very minimal modification of the ctypes stubs you would produce now
<beginner42>
does it need core and things like that?
<dsheets>
no, it stands alone
<dsheets>
well, having ocamlfind will help with install (obv) and it uses ounit for tests (if you run them)
<dsheets>
additionally, a ctypes binding would let you iterate the interface to the library and, if you are later unhappy about performance, you could then write a binding without ctypes directly against ocaml's memory model
<mrvn>
beginner42: you should use bigarrays for the messages
<beginner42>
dsheets: have you tried ctypes, i just went over the main link and it seems comparably extremely simple to call c functions?
<NaCl>
dsheets: hi
<dsheets>
NaCl, you have a collision prone nick :-P
<NaCl>
heh.
<beginner42>
mrvn: could you elaborate your point?
<mrvn>
beginner42: if you use string then you need to copy the strings to a buffer before releasing the runtime and calling the zmq send function, reverse that for recv. With bigarray you can simply send/recv directly.
<mrvn>
ideal you should provide both string and bigarray though.
<dsheets>
i attempted to provide both string and bigarray in my bindings previously linked... would love feedback on the ergonomics of the design
<dsheets>
there is a (soon to be merged) branch of ctypes that provides direct bigarray access without a ctypes array intermediary
gnuvince has quit [Ping timeout: 264 seconds]
<beginner42>
dsheets: i just installed ctypes on my computer and will try to get it running
<dsheets>
beginner42, cool. let me know if you need help. I'll be here for a few hours and on again tomorrow. After that, email only for a few weeks.
<beginner42>
dsheets: thanks a lot. the email address on github?
avsm has joined #ocaml
<dsheets>
beginner42, ya, that would be fine
<beginner42>
dsheets: perfect, i will keep you posted
avsm1 has joined #ocaml
avsm has quit [Read error: Connection reset by peer]
pkrnj has quit [Quit: Computer has gone to sleep.]
<beginner42>
dsheets: when i have some_params @-> returning void in the ml file what would be the signature? just some_params -> void?
<dsheets>
beginner42, the ocaml signature will be the types used in the parameters in a function with a return type of unit
<beginner42>
ok, thanks
ollehar has joined #ocaml
<beginner42>
dsheets: for example the zmq version functioin returns void and the three int ptr contain the version number, how do i access them?
<beginner42>
mrvn: so BuildDepends: ctypes,ctypes.foreign?
<mrvn>
try just ctypes first
<beginner42>
thats what i had before, and that didnt work
<dsheets>
i am just using a makefile in my sodium bindings because I'm not sure how to get oasis to compile a proxy dynamic library for use in bytecode... so I wrote a little makefile and have the dll???.so generated by rule
<mrvn>
Library gui
<mrvn>
Install: false
<dsheets>
beginner42, if you are using the Foreign module for libffi bindings (yes), you need to import the ctypes.foreign package (and probably only that one as it depends on ctypes)
<beginner42>
dsheets: i have installed libffi-dev. I get this fatal error .opam/4.00.1/lib/stublibs/dllctypes-foreign_stubs.so: undefined symbol: zmq_version")
<mrvn>
do you link zmq?
<mrvn>
in the right order?
<beginner42>
cclib: -lzmq
<beginner42>
or do i need dlllib?
<dsheets>
probably need both if you are building both native and bytecode bindings but, again, i'm not familiar with oasis' binding support
<mrvn>
dsheets: That picture is zoomed in so much that double aren't precise enough to give different values for each pixel so you get blocks. And rounding errors make it slightly out of phase with the picture before that so scaling the last picture and filling only the gaps gives the pixel artifacts.
<dsheets>
mrvn, yes, this seems to be a common problem when writing a fractal viewer
<dsheets>
mrvn, have you considered using a window/divisor method to retain precision?
<dsheets>
iirc, you can track the coordinates of the viewport and perform some of the operations symbolically to get a few more orders of magnitude more precision
<mrvn>
that might help the image not getting out of sync with the previous one but leaves the blocks.
<dsheets>
or simply calculate the maximum depth you can reach precisely and then switch to an infinite precision representation with a performance hit
<mrvn>
infinite precision won't work. that would make the number double in size for every iteration and you have like 1000000 of those.
<mrvn>
But I will need some optimized fixed point module to go deeper than 2^100.
<dsheets>
you can perform truncation between iterations at something like 2x the required precision for this level
<dsheets>
not perfect of course
<dsheets>
(incidentally, a mandelbrot viewer was my first ocaml program)
<dsheets>
then i printed some nice shots with a color plotter :-P
<mrvn>
I'm now trying to make a movie flying into the height mapped mandelbrot. But I need to implement rotation so it isn't just a zoom.
<dsheets>
oh, cool. so like fractal fjords?
* dsheets
looks at web site and confirms
<dsheets>
that's awesome. what are you using to render?
<mrvn>
jep. And if you dive into a spiral and follow it the image should tilt like the view from a plane would.
<dsheets>
i suggest quaternions for rotation :-P
<mrvn>
The images are just some ocaml code doing a prallel projection with shadows.
<mrvn>
the z axis is projected along the y axis. So it is simply y = y + z / 2
<mrvn>
I'm not sure if a projection with perspective works with fractals
<dsheets>
mrvn, why not? you have a camera at a (virtual) position. it should be possible to shoot rays from the camera through the projection plane into the fractal?
<dsheets>
in interesting problem indeed
<mrvn>
but will it look good?
<dsheets>
how strong is your magic?
gnuvince has joined #ocaml
gnuvince has quit [Changing host]
gnuvince has joined #ocaml
<mrvn>
good enough I think
<dsheets>
:-)
avsm1 has quit [Quit: Leaving.]
<mrvn>
The shadows make things complicated too. I need to compute pixels outside the visible area to check if they throw a shadow inside the picture.