<mrvn>
It somehow corrupts the memory causing segfaults in unrelated code.
ski has joined #ocaml
f[x] has joined #ocaml
<flux>
are bigarrays guaranteed not to be moved by the gc?
<flux>
but, I finally wrote a useful piece of code using ParserCo. not sure if it was worth it, though :).
<flux>
maybe if a companion module for ParserCo was introduced, that would be more string-friendly (at present it doesn't know about strings)
<flux>
and also such a module could support regular expressions as well
<flux>
thelema, I believe ParserCo.none_of is broken, btw. it shouldn't have "not" in the front of the predicate function, should it?
<mrvn>
flux: The ->data part is malloced so it should be outside the heap.
<flux>
and b as well?
<mrvn>
Plus the bigarray is only read so it shouldn't corrupt memory.
<mrvn>
flux: hmm, no. I should get b->data before entering the blocking section
<mrvn>
But again, only read access.
<flux>
what if you remove the code from caml_md5_update_bigarray, does the problem still occur?
<flux>
or at the very least, remove the call to caml_MD5Update
<mrvn>
flux: caml_MD5Update writes to ctx but that is malloced by me and has sensical values. I will try but I can't think of anything that could be wrong there.
ikaros has joined #ocaml
<flux>
mrvn, well, if the problem happens without caml_md5_update_bigarray doing any work, you should be able to narrow down the problem further
<mrvn>
The problem doesn't happen if I don't call caml_md5_update_bigarray
<flux>
well, it might just be that it doesn't torture gc enough
<flux>
you're doing some work there now in the blocking section
<flux>
I'm guessing the problem disappears if you take the blocking section away as well?
<mrvn>
caml_md5_update_bigarray doesn't allocate so bno change in amount of GC work. But the enter/leave changes things.
<mrvn>
think so.
yangsx has quit [Ping timeout: 260 seconds]
myu2 has quit [Remote host closed the connection]
jcaose has joined #ocaml
<mrvn>
I just had a segfault with caml_MD5Update commented out.
myu2 has joined #ocaml
joewilliams is now known as joewilliams_away
pimmhogeling has joined #ocaml
_zack has joined #ocaml
ttamttam has quit [Quit: Leaving.]
pimmhogeling has quit [Remote host closed the connection]
<mrvn>
ARRGGSSSS. Das problem scheint das "noalloc" zu sein.
<mrvn>
aeh, ELANG.
<mrvn>
Could it be that "noalloc" function MUST not use CAMLparam?
<flux>
sounds like a real possibility
ttamttam has joined #ocaml
<mrvn>
flux: Now I'm confused again. When I remove the CAMLparam2() I get segfaults.
<mrvn>
Isn't that only needed when you allocate something, i.e. when the GC can be triggered?
<flux>
thelema, how about if ParserCo.t also had a parameter for plural form? so one could have the current version ('a, 'a list) and then a character-specialization (char, string) or a unicode-specialization with (BatUTF8.t, Rope.t) ?
<flux>
mrvn, I wonder if CAMLparam2 could allocate then something? look at its definition?
<mrvn>
flux: CAMLparam2 creates a new root I believe.
<flux>
thelema, such a plural form could be used for one_of, zero_plus, etc
<flux>
so that crashes without caml_MD5Update as well?
<flux>
caml_MD5Update seems to be plain C
<mrvn>
it is.
<flux>
so I guess it cannot cause such trouble
<mrvn>
Can't get it to segfault again without it but that might just be a race condition
myu2 has quit [Remote host closed the connection]
<mrvn>
But what does calling CAMLparam2() change? The GC can't possibly run between the start of the function and the caml_enter_blocking_section(). And after that no ocaml values are used.
<mrvn>
I turned up Gc debugging and I see lots of GC activity.
myu2 has joined #ocaml
<flux>
crashes nicely for me as well
<mrvn>
comment in the CAML_param2 and CAMLreturn and it works.
<flux>
well, it stops crashing if I replace caml_MD5Update with { int c; for (c = 0; c <10000000; ++c); }
<mrvn>
which would indicate that the ctx pointer overlaps with some other memory.
pimmhogeling has joined #ocaml
<flux>
never thought of using Scanf that way, nice idea :)
<flux>
(atleast for simple test programs)
<mrvn>
Is there another function to convert string to int?
<flux>
int_of_string
<mrvn>
must have missed that
myu2 has quit [Remote host closed the connection]
<flux>
I replaced caml_MD5Update with { struct MD5Context ctx2; caml_MD5Update(&ctx2, data, len); } and the problem goes away in this case as well
<mrvn>
yeah. tried the same.
avsm has joined #ocaml
<flux>
replacing data with a gloabl 100MB array didn't remove the problem
<flux>
mrvn, did you notice that commenting free(ctx) solves the issue as well..
<mrvn>
nope.
<mrvn>
==8510== Invalid read of size 4
<mrvn>
==8510== Address 0x5b6d3b4 is 4 bytes inside a block of size 88 free'd
<mrvn>
Ahh, stupid me.
<flux>
:)
<mrvn>
Without CAMLparam2(context,...) nothing in foo.ml uses the context anymore. If the compiler makes the call tail recursive then the context is unreachable.
<mrvn>
Could that be what happens?
<mrvn>
wait, no. Can't be tail recursive because it i followed by "loop ()"
<mrvn>
But somehow the GC finalizes the context before "update_bigarray context buf" returns.
myu2 has joined #ocaml
<flux>
why would tail recursion affect anything?
<flux>
isn't it sufficient that without CAMLparam2 nothing indeed is holding on to the context anymore, if the calling code doesn't
<mrvn>
flux: because it ends the scope of variables
<mrvn>
flux: but shouldn't the calling code hold on to it till the last command ?
Yoric has quit [Remote host closed the connection]
Yoric has joined #ocaml
<flux>
true. removing decr num; from the calling thread (and making it infinite, thus holding context always) doesn't change a thing
<flux>
mm no wait
<flux>
you have let context = context () ni..
<flux>
so wouldn't ocaml see that the context goes away when you call that function..
<flux>
unless it hold on to it, which it doesn't
myu2 has quit [Remote host closed the connection]
<flux>
if I put the context creation before the loop, the crash goes away
<mrvn>
It must see that after the function call context is never used again so it drops it before calling with the assumption the called function will hold it itself?
<flux>
as far ocaml is concerned, the lifetime of context ends to the call of update_bigarray
<mrvn>
at the start of the call or at the end?
<flux>
well, let's say the function is let foo a = call_some_other_fun ()
<flux>
if you call foo context at some point and you don't hold on to context, it makes sense not to keep it aruond
<mrvn>
but that is a tail call
<flux>
let's say you have:
<flux>
let foo a = perform_operations a; do_some_other_work ()
<flux>
let rec loop () = let ctx = context () in foo ctx; loop ()
<flux>
it makes sense to me that ctx is dropped after perform_operation a
<mrvn>
but it is here dropped before.
<flux>
it would not be if loop () still keeps a reference to it
<flux>
well, from the ocaml's point of view it's the same?
<flux>
it doesn't really consider what happens inside a function
<flux>
let's consider two possibilities. first, loop does hold on to ctx: let rec loop () = let ctx = context () in foo ctx (* ok, loop holds on to ctx but drops it after call *); loop () -> in this case ctx cannot be dropped within foo (), because loop still holds on to it
<flux>
on the other hand if it does drop it, it will be really dropped when foo drops its reference, which I think is what is preferable..
<mrvn>
I just didn't think ocamlopt was that smart.
<flux>
it's best to play by the rules instead of assuming ocaml isn't and never will be as smart :)
<mrvn>
flux: The problem is that the caml_enter_blocking_section() means that some other thread can alloc (and trigger GC) in parallel. So the code really isn't "noalloc" anymore.
<mrvn>
But I would never have guessed the problem is the finalizer being run too early.
<flux>
funny how my log processing didn't reveal that
<flux>
I guess the log message is produced too early
<flux>
I processed the output to find uses of context after finalizing it
<mrvn>
In most cases the next context just uses the same spot again.
<mrvn>
I only spotted it in valgind when I added fprintf to the finalizer.
<flux>
I scanned for all creations, uses and finalizations and ensured that a context must be created dusing usage
<flux>
but I guess md5 takes such a long time that it can free it while it's processing
<mrvn>
it does.
<mrvn>
7.3ms on my system for 1MB.
<mrvn>
I still find it odd how it triggers random segfaults in other code and even causes the GC to report out of memory.
<mrvn>
The GC and other code must malloc() stuff for a short while and get the same region the ctx was in before.
<mrvn>
Lets see if it still all works when I put it back into the compiler itself.
<mrvn>
flux: Doing this with bigarray and enter_blocking_section() does wonders for the core utilization.
<flux>
mrvn, no wonder, 7.3ms is a decent amount of work
ikaros has quit [Quit: Leave the magic to Houdini]
<mrvn>
Atom330 cpus aren't fast.
<mrvn>
Takes 7.3s to md5sum 1GB with one core, 10s with 4 cores (added together).
<mrvn>
Not quite sure why more threads take so much more time.
<flux>
mrvn, btw, maybe you should add a lower-bound size that prevents enter/leave_blocking_section, so things like looping over single bytes doesn't yield insane locking overhead
<mrvn>
flux: maybe. That needs to be measured I guess.
<mrvn>
I don't expect someone to use single byte *big*arrays though.
<mrvn>
mfp: How is that 3rd answere relevant?
<mfp>
mrvn: it gives an upper bound for the cost of caml_leave_blocking_section
<mrvn>
ahh, you mean because the example code measures the speed of the mutex.
<mfp>
pthread_cond_signal
<flux>
mrvn, well, a subarray might be small..
<mrvn>
mfp: I guess with more threads it is more likely two threads want the mutex and need to wait for the condition. That could explain the increase in time
<mrvn>
Is there a define for the systems pagesize?
<mfp>
#include <unistd.h> sysconf(PAGESIZE)
<mrvn>
I don't want to make a function call for every test.
<mrvn>
Doesn't ocaml store that somewhere?
<mfp>
(_SC_PAGESIZE in fact)
<mfp>
got it
<mfp>
<caml/config.h> -> Page_size
<mrvn>
#define Page_log 12 /* A page is 4 kilobytes. */
<mrvn>
stupid lower case :)
<mrvn>
How does ocaml work on systems with variable pagesize? e.g. ppc.
<mrvn>
./foo 1 7.31s user 0.01s system 100% cpu 7.324 total
<mrvn>
./foo 2 8.54s user 0.02s system 193% cpu 4.419 total
<mrvn>
./foo 3 10.48s user 0.03s system 294% cpu 3.568 total
<mrvn>
./foo 4 11.14s user 0.06s system 365% cpu 3.067 total
<mrvn>
./foo 16 9.75s user 0.16s system 381% cpu 2.599 total
zhijie has quit [Read error: Connection reset by peer]
<mrvn>
works repeadatly. Juhey.
zhijie has joined #ocaml
valross has quit [Quit: Ex-Chat]
zhijie has quit [Read error: Connection reset by peer]
<mrvn>
Should I make the Digest.context thread safe? Meaning what if someone creates a context and then uses it in 2 threads?
<mrvn>
Without lock the result would be completly random. With lock it would be one of 2 results.
zhijie has joined #ocaml
<flux>
if it doesn't crash, it's safe enough
<mrvn>
As long as it isn't finalized it won't crash :)
<mrvn>
Has anyone written custom_operations before? I've only written finalize() yet but I think I should write the others too for Digest.context.
<flux>
I'm not sure, but shuoldn't be difficult. atleast you should provide compare. maybe hash.
<mrvn>
serialize is needed for Marshal, right?
<mfp>
yes
hyperboreean has quit [Remote host closed the connection]
zhijie has quit [Read error: Connection reset by peer]
zhijie has joined #ocaml
avsm1 has joined #ocaml
oc13 has quit [Quit: Leaving.]
avsm has quit [Ping timeout: 256 seconds]
<mrvn>
What is a prime number smaller than 31bit int?
pimmhogeling has quit [Read error: Connection reset by peer]
<quelqun_dautre>
a prime number that fit in a 31bit int.
<mrvn>
yes. But I need such a number. The largest one
<mrvn>
Largest prime smaller than max_int on 32bit cpus.
<mrvn>
let sde3 trainData lr maxiterations winit =
<sc30317>
mrvn, got it
Smerdyakov has joined #ocaml
jcaose has quit [Quit: Leaving]
<sc30317>
can I increment an int? (similar to i++ in c?)
<mrvn>
nope. only a ref
<sc30317>
so if i have i = 0 in
<sc30317>
I would have to do i = 1 in to increment it?
<Smerdyakov>
sc30317, when you have another question like that, first ask yourself whether you can do it in math. If not, you probably can't in OCaml, either.
<sc30317>
Smerdyakov, sounds good
<mrvn>
sc30317: that doesn't increment it. That just creates a new one
<sc30317>
ok
<mrvn>
# let i = 1 in (let i = 2 in i) + i;;
<mrvn>
- : int = 3
{newbie} has quit [Quit: {newbie}]
<sc30317>
thanks mrvn
* Smerdyakov
thinks: This is the kind of question that people don't have when they learn programming languages along with program logics.
<sc30317>
Smerdyakov, i'm sorry; im trying really hard with this
<mrvn>
It shows a fundamental lack of understanding what functional programming is
<Smerdyakov>
sc30317, I'm not trying to cast aspersions on you. Instead, I'm commenting on the widespread use of poor pedagogy.
* mrvn
too
<sc30317>
Smerdyakov, thats definitely true :D
<mrvn>
sc30317: Did your course start off with implementing a factorial function? List manipulations?
<sc30317>
nope, nothing
<sc30317>
just got thrown into this
<sc30317>
is there a way to convert a list to a string?
<mrvn>
Doing 3D vector/matrix multiplications is really no way to learn ocaml.
<mrvn>
sc30317: yes
<sc30317>
mrvn, I agree with you
<mrvn>
Wherer there is a will there is a way
<sc30317>
mrvn, true
<sc30317>
I guess I should have worded my question differently
<sc30317>
is there a standard function to convert a List to a string
<Smerdyakov>
sc30317, your question is too vague.
<Smerdyakov>
sc30317, so far, an answer is: "Yes, the function that always returns the empty string."
<sc30317>
Smerdyakov, let me word it better
<sc30317>
I have a List of lists
<Smerdyakov>
[There's no reason to capitalize "list" there.]
<sc30317>
I would like to turn that into a string so that I can print it out using print_string
<Smerdyakov>
You should try to avoid IO in OCaml, especially as a beginner.
<Smerdyakov>
Instead, just evaluate the expression whose value you're curious about.
<sc30317>
Smerdyakov, I know- but that is what this program has to do
<mrvn>
let implode list = let s = String.create (List.length list)# let implode list = let s = String.create (List.length list) in let rec loop i = function [] -> s | c::cs -> s.[i] <- c; loop (i + 1) cs in loop 0 list;;
<mrvn>
val implode : char list -> string = <fun>
<mrvn>
# implode ['H';'a';'l';'l';'o'];;
<mrvn>
- : string = "Hallo"
<sc30317>
mrvn, thanks
<sc30317>
I am working on some code
<sc30317>
I will post in a second to ask questions about
{newbie} has joined #ocaml
<mrvn>
# let string_of_vec v = List.fold_left (fun s x -> Printf.sprintf "%s %f" s x) "" v;;
<mrvn>
val string_of_vec : float list -> string = <fun>
<mrvn>
# string_of_vec [1.0; 2.0; 3.0];;
<mrvn>
Now you do string_of_matrix
<mrvn>
- : string = " 1.000000 2.000000 3.000000"
<sc30317>
but I would like to leave the brackets and semicolons in
<Smerdyakov>
mrvn, how do you know that you aren't writing a significant portion of his homework solution for him right now?
avsm has quit [Quit: Leaving.]
<sc30317>
and it is going to be a List of Lists or a List
avsm has joined #ocaml
<Smerdyakov>
Please stop capitalizing "list."
<sc30317>
sorry Smerdyakov
avsm has quit [Client Quit]
<albacker>
do you guys also solve Java homework?
<Smerdyakov>
sc30317, your first source of help should be course staff. Have you asked them these questions yet?
<sc30317>
yes
<sc30317>
he says RTFM
<sc30317>
literally
<Smerdyakov>
You might want to complain to some higher power within the university.
<sc30317>
I would; however, my professor is the higher power
<Smerdyakov>
He's the university president? :)
<sc30317>
no
<sc30317>
he is the head of the department
<Smerdyakov>
You might want to switch universities. :P
<sc30317>
last semester
<Smerdyakov>
What is the subject matter of this class?
<sc30317>
programming languages
<sc30317>
he is teaching us 4 different ones this semestter
f[x] has quit [Ping timeout: 240 seconds]
mrvn has quit [Ping timeout: 258 seconds]
<albacker>
thats really general in my opionion
<sc30317>
albacker, I agree
mrvn has joined #ocaml
<Smerdyakov>
It seems to be a universal truth that 90% of students can't learn OCaml in less than a full dedicated semester.
<albacker>
i'm in 2nd year of university and i've had several subjects for several languages. even 2 subjects for one language
<Smerdyakov>
albacker, what are you trying to convey by giving that link?
<albacker>
one semester is not enough for anything :D
{newbie} has quit [Quit: {newbie}]
<Smerdyakov>
That's obviously false, so I'll ignore it unless you make a more specific statement. :P
<albacker>
nice article btw, i invite you to read it.
* Smerdyakov
spends 999 hours trying to find the code that does the default scaffolding in Ruby on Rails, just so he can count the number of lines in it. :(
f[x] has joined #ocaml
smimou has quit [Ping timeout: 260 seconds]
smimou has joined #ocaml
f[x] has quit [Ping timeout: 240 seconds]
joewilliams_away is now known as joewilliams
philtor has joined #ocaml
tmaeda has quit [Ping timeout: 246 seconds]
<ttamttam>
Hello
<ttamttam>
I have a small question about camlp4
<ttamttam>
I'd like to see the code (pretty printer part) generated when applying a syntax extension on a source file
<ttamttam>
But can't figure out how to do.
<ttamttam>
I tried some variations around : camlp4o -I .. bitstring.cma bitstring_persistent.cma pa_bitstring.cmo toto.ml
<ttamttam>
But this produces (?) byte code ?
tmaedaZ has joined #ocaml
f[x] has joined #ocaml
<mfp>
ttamttam: add pr_o.cmo to the list of modules, otherwise camlp4o will generate a binary serialization of the AST when you redirect the output
<ttamttam>
mfp: Thanks ;-)
<Smerdyakov>
How ugly is _that_....
philtor has quit [Ping timeout: 256 seconds]
ttamttam has quit [Quit: Leaving.]
oc13 has joined #ocaml
<sc30317>
can I do a for loop like this?
<sc30317>
for( i = 0 to head_length(x) do
<sc30317>
print_float List.nth(x) i
<sc30317>
done
<Smerdyakov>
Please don't use loops in OCaml. I wish they weren't in the language.
<thelema>
sc30317: Smerdyakov is our resident purist
<Smerdyakov>
His particular example is just dying for one of the most standard higher-order functions.
<sc30317>
Smerdyakov, ok
<thelema>
Smerdyakov: yes, he's not yet learned about map and iter
<sc30317>
if I don't use a loop, then how would you print the floats in a list?
f[x] has quit [Ping timeout: 268 seconds]
<Smerdyakov>
An awful loop may be the best choice given your crappy course situation.
<thelema>
List.iter print_float x
<Smerdyakov>
That will do what a reasonable fix-up of his code would do, but it won't do what he really wants. :D
<sc30317>
Smerdyakov, you are right
<sc30317>
if I do the List.iter print_float x
<sc30317>
it prints them all out
<sc30317>
but it doesn't add a space
<sc30317>
in between each float
<sc30317>
is there a way I can add a space?
<schmx>
maybe make a function that prints the space \o/
<jonafan>
or use the printf module
<sc30317>
well I could make a module that prints a space or use the printf module, but that doesn't make a space between each iteration in the List.iter
<schmx>
unless.. you use that for iteration.
<sc30317>
schmx, how do you mean?
<jonafan>
List.iter (Printf.printf "%f ") x
<sc30317>
jonafan, oh ok
<jonafan>
there are handy formatting options too
<sc30317>
gotcha
<jonafan>
another option: convert floats to strings and use String.concat
<mfp>
_andre: why do you want multiple processes anyway?
<thelema>
clearly so he can satisfy the million hits per day his site is getting.
<mfp>
(Ocsigen's Eliom is not a blocking framework à la Rails)
Yoric has joined #ocaml
<_andre>
well, i figured if i have multiple cores i could use them
<thelema>
he needs to take advantage of his 32-core web-servers.
<_andre>
funny.
<thelema>
8-CPU quad core boxes. They're the wave of the future.
<_andre>
mfp: i'm just getting started with ocsigen, it was just something i was wondering about
<_andre>
pre-fork + lwt for each core seems to make sense for me
_zack has quit [Read error: Connection reset by peer]
_zack has joined #ocaml
<sc30317>
I have a number
<sc30317>
and I have to make a vector that is x of those numbers
<sc30317>
how do I create this vector?
<sc30317>
ex.
<sc30317>
if I input .25 and I have a length of 3
<sc30317>
then the output vector needs to be [.25;.25;.25]
<thelema>
well, batteries' List.init would work great. Otherwise you'll have to write your own recursive function. pretty trivial
<sc30317>
ok
demitar has joined #ocaml
<sc30317>
how would I write my own recursive function?
<sc30317>
let rec vector_create lr = function [], | ::lr
<sc30317>
would something like that work?
<thelema>
let dup n x = x :: dup (n-1) x
<thelema>
but better.
<sc30317>
but better?
<thelema>
yes, with a base case for the recursion
smimou has quit [Ping timeout: 268 seconds]
<sc30317>
oh ok
<sc30317>
h/o let me see if I can come up with something
smimou has joined #ocaml
<sc30317>
thelema, if I do what you said, I get a syntax error
<sc30317>
let rec dup n x = x :: dup (n-1) x
<thelema>
rec?
<sc30317>
yea I fixed that
<sc30317>
I was trying to figure out something else wrong with hit
<sc30317>
*with it
<thelema>
no syntax error on my box
<thelema>
value dup : int -> 'a -> list 'a = <fun>
<sc30317>
val dup : int -> 'a -> 'a list = <fun>
<thelema>
oh yeah, revised types.
<thelema>
ignore the difference
<sc30317>
oh ok
<sc30317>
but then if I put in dup 0.25 10;;
<thelema>
if you run it, it'll overflow the stack.
<sc30317>
Error: syntax error
<sc30317>
yea I got that error too
smimou has quit [Ping timeout: 268 seconds]
<sc30317>
why?
<thelema>
odd that it gives you a syntax error
<sc30317>
no I was just being an idiot
<sc30317>
now its a stack overflow
<sc30317>
why would that be?
<sc30317>
no base case?
<jonafan>
stack overflow is caused by too many recursive function calls
<sc30317>
jonafan, thats what I figured
<jonafan>
in this case, recursion can never terminate
<thelema>
yes, no base case
<sc30317>
what would I need to do to add the base case?
<thelema>
check if n=0
<jonafan>
in what situation would you want to return an empty list?
<sc30317>
jonafan, if there is no number entered?
<jonafan>
okay so build on that
<sc30317>
let rec dup n x = x :: dup (n-1) x
<sc30317>
if n = 0 failwith "no base case"
<jonafan>
haha
<sc30317>
well you told me to build on it?
<sc30317>
haha
<jonafan>
your function, the first thing it should do is check for n being less than or equal to 0
<jonafan>
if it is zero, it returns an empty list
<jonafan>
otherwise, it returns x :: (your function with n - 1)
<jonafan>
let rec dup n x = if x <= 0 then [] else x :: dup (n - 1) x
<sc30317>
haha thats what I was just about to say joewilliams_away
<sc30317>
thats what I was just about to say jonafan
<jonafan>
there are more tricks available to make it more efficient, but it's probably not worth the effort
<jonafan>
you could make a tail recursive version using an accumulator
<jonafan>
let dup n x = let rec f n accum = if n <= 0 then accum else f (n - 1) (x :: accum) in f n []
<jonafan>
also don't write your functions on one line like that
<sc30317>
I don't
<derdon>
rwmjones: ping
<sc30317>
I can't see them that way
_zack has quit [Quit: Leaving.]
oc13 has quit [Ping timeout: 248 seconds]
smimou has joined #ocaml
oc13 has joined #ocaml
tmaedaZ has quit [Ping timeout: 276 seconds]
itewsh has quit [Quit: There are only 10 kinds of people: those who understand binary and those who don't]
ikaros has joined #ocaml
tmaedaZ has joined #ocaml
f[x] has joined #ocaml
smimou has quit [Ping timeout: 268 seconds]
ttamttam has quit [Quit: Leaving.]
smimou has joined #ocaml
rwmjones has quit [Ping timeout: 256 seconds]
smimou has quit [Read error: Operation timed out]
rwmjones has joined #ocaml
<derdon>
rwmjones: helo
<derdon>
rwmjones: I think I found a typo in a wiki article
smimou has joined #ocaml
<thelema>
derdon: email him for a logon, or I can fix it now.
<derdon>
thelema: the problem is, that I don't understand the sentence. technically, I could fix it as well. it is in http://www.ocaml-tutorial.org/compiling_with_gnu_make: "Note that libraries that not part of the standard library but are shipped with any standard OCaml installation such as unix, str or bigarray are automatically considered as Findlib packages."
jcaose has joined #ocaml
<thelema>
better?
enthymeme has quit [Quit: rcirc on GNU Emacs 23.1.1]
<derdon>
yep
Associat0r has joined #ocaml
Yoric has quit [Read error: Connection reset by peer]
Yoric has joined #ocaml
Associat0r has quit [Client Quit]
smimou has quit [Read error: Operation timed out]
enthymeme has joined #ocaml
<thelema>
eek! I'm blinded looking at the code menhir produces
<thelema>
I'm about to find out what happens when you have an ocamllex rule that matches the empty string
ulfdoz has quit [Ping timeout: 246 seconds]
mrvn has quit [Ping timeout: 240 seconds]
mrvn has joined #ocaml
smimou has joined #ocaml
smimou has quit [Changing host]
smimou has joined #ocaml
jeddhaberstro has joined #ocaml
matthieu has joined #ocaml
matthieu has quit [Remote host closed the connection]
maattd has joined #ocaml
Submarine has quit [Quit: Leaving]
sepp2k has quit [Quit: Leaving.]
oc131 has joined #ocaml
maattd has quit [Remote host closed the connection]
oc13 has quit [Ping timeout: 276 seconds]
rwmjones has left #ocaml []
rwmjones has joined #ocaml
Drk-Sd has joined #ocaml
<rwmjones>
derdon, didn't I send you an invite before? I thought I did ..
<derdon>
rwmjones: yes, you did. Like I already said, "technically, I could fix it"
<derdon>
rwmjones: but I didn't understand what you wanted to express with the original sentence
<rwmjones>
ah ok ... looks like thelema fixed it anhow
<rwmjones>
anyhow
<derdon>
yes
<thelema>
I gave my best try.
jcaose has quit [Quit: Leaving]
<thelema>
I like getting emails on updates to the wiki, so I can see tiny things that can be written better.
<thelema>
I can't take up all my time editing the wiki, so it's good that there's not too many changes
<derdon>
I removed an HTML tag inside a code block cus it was visible there as is
<derdon>
so I used ReST notation: ``foo``
<derdon>
thelema and rwmjones: are you currently working on any ocaml project?