#ocaml on 2012-09-21 — irc logs at freenode.irclog.whitequark.org

2011-07-12 19:41 gildor changed the topic of #ocaml to: Discussions about the OCaml programming language | http://caml.inria.fr/ | OCaml 3.12.1 http://bit.ly/nNVIVH

00:01 lggr has quit [Ping timeout: 240 seconds]

00:05 <Ptival> hi guys, do you know if there's a way to query the lib directory of ocaml?

00:07 lggr has joined #ocaml

00:14 lggr has quit [Ping timeout: 264 seconds]

00:19 lggr has joined #ocaml

00:23 <Qrntz> Ptival, «ocamlc -where»?

00:26 <Ptival> Qrntz: thanks

00:26 lggr has quit [Ping timeout: 248 seconds]

00:31 lggr has joined #ocaml

00:38 lggr has quit [Ping timeout: 252 seconds]

00:43 err404 has quit [Remote host closed the connection]

00:43 lggr has joined #ocaml

00:50 lggr has quit [Ping timeout: 244 seconds]

00:55 lggr has joined #ocaml

00:59 lggr has quit [Ping timeout: 248 seconds]

01:06 lggr has joined #ocaml

01:10 emmanuelux has quit [Ping timeout: 246 seconds]

01:11 lggr has quit [Ping timeout: 252 seconds]

01:15 Yoric has quit [Ping timeout: 246 seconds]

01:18 lggr has joined #ocaml

01:19 madroach has quit [Ping timeout: 265 seconds]

01:21 madroach has joined #ocaml

01:23 lggr has quit [Ping timeout: 256 seconds]

01:29 lggr has joined #ocaml

01:36 lggr has quit [Ping timeout: 248 seconds]

01:41 lggr has joined #ocaml

01:48 lggr has quit [Ping timeout: 256 seconds]

01:54 lggr has joined #ocaml

01:54 Catnaroek has joined #ocaml

01:55 hongboz has joined #ocaml

01:58 lggr has quit [Ping timeout: 252 seconds]

02:01 lggr has joined #ocaml

02:05 lggr has quit [Ping timeout: 245 seconds]

02:12 lggr has joined #ocaml

02:18 lggr has quit [Ping timeout: 260 seconds]

02:24 lggr has joined #ocaml

02:28 lggr has quit [Ping timeout: 252 seconds]

02:36 lggr has joined #ocaml

02:40 lggr has quit [Ping timeout: 246 seconds]

02:45 lggr has joined #ocaml

02:52 lggr has quit [Ping timeout: 268 seconds]

02:57 lggr has joined #ocaml

03:02 lggr has quit [Ping timeout: 264 seconds]

03:09 lggr has joined #ocaml

03:12 ghostbuster2 has joined #ocaml

03:14 lggr has quit [Ping timeout: 244 seconds]

03:15 fraggle_ has joined #ocaml

03:16 lggr has joined #ocaml

03:23 lggr has quit [Ping timeout: 264 seconds]

03:26 osa1 has quit [Quit: Konversation terminated!]

03:31 lggr has joined #ocaml

03:38 lggr has quit [Ping timeout: 264 seconds]

03:42 everyonemines has joined #ocaml

03:43 lggr has joined #ocaml

03:47 lggr has quit [Ping timeout: 260 seconds]

03:55 lggr has joined #ocaml

03:58 Yoric has joined #ocaml

03:59 lggr has quit [Ping timeout: 246 seconds]

04:04 lggr has joined #ocaml

04:09 lggr has quit [Ping timeout: 240 seconds]

04:14 BiDOrD has joined #ocaml

04:14 lggr has joined #ocaml

04:17 BiDOrD_ has quit [Ping timeout: 268 seconds]

04:18 lggr has quit [Ping timeout: 240 seconds]

04:19 ghostbuster2 has quit [Ping timeout: 264 seconds]

04:23 wmeyer has quit [*.net *.split]

04:23 testcocoon has quit [*.net *.split]

04:23 snarkyboojum has quit [*.net *.split]

04:23 thelema_ has quit [*.net *.split]

04:24 wmeyer has joined #ocaml

04:24 lggr has joined #ocaml

04:28 45PAA27RV has joined #ocaml

04:28 testcocoon has joined #ocaml

04:28 snarkyboojum has joined #ocaml

04:28 thelema_ has joined #ocaml

04:28 lggr has quit [Ping timeout: 248 seconds]

04:29 45PAA27RV has quit [Ping timeout: 244 seconds]

04:29 thelema_ has quit [Write error: Broken pipe]

04:30 thelema has joined #ocaml

04:34 Catnaroek has quit [Quit: brb gais]

04:34 lggr has joined #ocaml

04:39 lggr has quit [Ping timeout: 268 seconds]

04:43 Yoric has quit [Ping timeout: 252 seconds]

04:46 lggr has joined #ocaml

04:52 lggr has quit [Ping timeout: 244 seconds]

04:58 lggr has joined #ocaml

05:05 lggr has quit [Ping timeout: 246 seconds]

05:10 lggr has joined #ocaml

05:17 lggr has quit [Ping timeout: 264 seconds]

05:22 lggr has joined #ocaml

05:29 lggr has quit [Ping timeout: 256 seconds]

05:34 lggr has joined #ocaml

05:40 lggr has quit [Ping timeout: 246 seconds]

05:45 lggr has joined #ocaml

05:52 lggr has quit [Ping timeout: 264 seconds]

05:57 lggr has joined #ocaml

06:01 thomasga has joined #ocaml

06:02 lggr has quit [Ping timeout: 245 seconds]

06:09 lggr has joined #ocaml

06:14 lggr has quit [Ping timeout: 248 seconds]

06:22 lggr has joined #ocaml

06:26 tufisi has joined #ocaml

06:26 err404 has joined #ocaml

06:28 Snark has joined #ocaml

06:28 lggr has quit [Ping timeout: 246 seconds]

06:30 lggr has joined #ocaml

06:35 lggr has quit [Ping timeout: 246 seconds]

06:39 pango is now known as pangoafk

06:39 lggr has joined #ocaml

06:40 djcoin has joined #ocaml

06:42 Snark has quit [Ping timeout: 246 seconds]

06:44 lggr has quit [Ping timeout: 264 seconds]

06:52 lggr has joined #ocaml

06:57 sepp2k has joined #ocaml

06:59 lggr has quit [Ping timeout: 264 seconds]

07:00 <fasta> How do you think GHC and the ocaml compiler compare? By sheer number of commits, GHC has had much more work, but that's of course only one variable and not a very useful one (perhaps GHC developers changed their backend 10 times for no good reason, etc. ).

07:04 lggr has joined #ocaml

07:10 cago has joined #ocaml

07:10 lggr has quit [Ping timeout: 244 seconds]

07:12 mika1 has joined #ocaml

07:12 edwin has joined #ocaml

07:15 Yoric has joined #ocaml

07:15 lggr has joined #ocaml

07:19 hkBst has joined #ocaml

07:19 hkBst has quit [Changing host]

07:19 hkBst has joined #ocaml

07:20 lggr has quit [Ping timeout: 245 seconds]

07:22 <flux> ocaml is faster (in compilation), ghc has much more advanced optimizations. ocaml is probably easier to grasp & hack, no idea about ghc.

07:22 ocp has joined #ocaml

07:22 edwin has left #ocaml []

07:23 <fasta> I have the impression that by first putting your program in tons of monadic layers, that it will be nothing short of a miracle if all those indirections are removed.

07:23 <fasta> That is: the input language for typical Haskell programs is vastly more difficult than those of OCaml programs.

07:23 <fasta> The default lazyness also adds to this problem.

07:24 <fasta> While in principle it would be nicer to write in Haskell, it's just that it really isn't a language very well suited for execution on a Von Neumann architecture.

07:25 <fasta> I have no doubt that such a miracle compiler could potentially be written. It's just that you would have to wait an hour to compile a 50 line program.

07:26 <flux> I think the greatest 'danger' is that first you have fast code. then you make small modification. then suddenly your code doesn't satisfy some pattern, doesn't get optimized, and thus performs poorly.

07:26 <flux> not sure if that happens in real life, though.

07:26 <fasta> Sure, the 50lines ~ hour thing is not how it is currently.

07:26 <flux> at least the stream fusion optimization sounds like something that has great opportunities for that to happen

07:27 <fasta> I also think the language itself is more complex to parse by a computer.

07:28 <fasta> There is a good reason why people say you have to develop a limited lookahead language.

07:28 lggr has joined #ocaml

07:28 <fasta> Haskell is basically what results if you create some academic beauty, and OCaml is the result if you have a bunch of people who develop a language with industry feedback.

07:29 <fasta> At least, AFAIK OCaml has been in use by French companies for a very long time.

07:29 <flux> but there's no denying that haskell has a lot of people writing code for it

07:29 tufisi has quit [Ping timeout: 245 seconds]

07:29 <fasta> flux: yeah, but how useful is it?

07:29 <flux> it's nice to be able to build new code and find that the pieces of puzzle have already been written&debugged by some other people

07:30 <flux> although I haven't particularly found things missing in the ocaml land either

07:30 <fasta> flux: even gaussian elimination libraries didn't work 3 years ago in Haskell.

07:30 <flux> and then there's caml4perl ;)

07:30 <flux> (which actually works and is pretty nice to use, at least for small things)

07:30 <fasta> flux: also for OCaml4?

07:31 <fasta> flux: I think the only nice thing is the parallelism, but if you first lose a factor of 4 in single-threaded performance in Haskell, no amount of parallelism is going to catch up to that.

07:31 <flux> actually the name was perl4caml. basically ocaml bindings for the perl library, allowing to execute perl code in the same process

07:31 <fasta> flux: yes, I tried it with OCaml3.something.

07:32 <flux> I think I've used it for doing puny-encoded domain names

07:32 <flux> but then the algorithms wasn't that complicated that I just wrote it myself, to rid myself of the dependency. but it worked alright before.

07:32 <fasta> Perl libraries aren't that good either.

07:32 <fasta> For example, I was using strptime.

07:32 hkBst has quit [Read error: Connection reset by peer]

07:32 <fasta> Then I upgraded the library and it stopped working...

07:32 lggr has quit [Ping timeout: 252 seconds]

07:32 <flux> the quality varies, but I think many libraries are quite alright. and they encourage putting tests that are always executed during the install.

07:32 <djcoin> Purity makes Haskell very different from Ocaml. Hard to compare the compiler and such then.

07:32 <fasta> (so, I switched to Ruby for that specific problem)

07:33 <fasta> flux: what do you prefer now?

07:33 hkBst has joined #ocaml

07:33 <flux> fasta, I prefer OCaml

07:33 <fasta> djcoin: you can write pure OCaml if you want without too much problems.

07:33 <fasta> AFAIK, it's only mutable when you use the word mutable.

07:33 <flux> although if I need to do a small app that needs access to some C library without bindings - then I use C

07:34 <flux> or if it's text processing, or at work, I'll likely use Perl

07:34 djcoin has quit [Quit: WeeChat 0.3.7]

07:34 <fasta> flux: is there any reason why you wouldn't use it at work?

07:34 <flux> I haven't actually written anything worthwhile in Haskell.

07:34 djcoin has joined #ocaml

07:34 <flux> fasta, I like my colleagues to be able to read and modify it

07:34 <djcoin> damn, bug oO

07:35 <fasta> flux: and they are scared of OCaml?

07:35 <djcoin> fasta: the problem is not that you can wirte pure code of ocaml

07:35 <flux> fasta, they don't even know what it is

07:35 chambart has joined #ocaml

07:35 <djcoin> it is that you can't write unpure code in haskell

07:35 <fasta> flux: as in: never heard of it?

07:35 hkBst has quit [Excess Flood]

07:35 <flux> correct

07:35 <djcoin> Thus the compiler can't perform tremendous optimization

07:35 <flux> actually I've written a valgrind log analyzer in ocaml at work

07:35 lggr has joined #ocaml

07:35 <fasta> djcoin: define 'unpure'.

07:36 <fasta> djcoin: there is no definition of pure.

07:36 <flux> ..and at previous place I wrote a lot of other things, but there were a lot fewer people there (2)

07:36 <flux> (as in people coding)

07:36 <djcoin> impure *

07:36 <djcoin> fasta: no side effects at all, no modification of datastructure

07:36 Cyanure has joined #ocaml

07:36 <fasta> djcoin: the ST monad provides side-effects.

07:37 <fasta> djcoin: also, I wouldn't even use a language which didn't provide side-effects in the first place.

07:37 <djcoin> fasta: why ?

07:37 <fasta> AFAIK, all database datastructures are written in C++ and are full of mutation.

07:37 <flux> fasta, well, it only provides them as an optimization (the ST monad), you can implement ST monad functionally as well. it just won't perform as well.

07:37 <fasta> djcoin: because certain algorithms depend on it.

07:37 <fasta> djcoin: (for algorithmic complexity reasons, that is)

07:38 <fasta> djcoin: it's the same with uninitialized memory.

07:38 hkBst has joined #ocaml

07:38 <fasta> djcoin: if it's impossible to have an array filled with garbage, then it's probably not a serious programming language.

07:38 <fasta> (all of these things are possible in Haskell, btw)

07:38 <djcoin> fasta: if you need perf you could also code it in C/C++I guess

07:39 <fasta> djcoin: everyone always needs performance.

07:39 <fasta> djcoin: it's just that sometimes people give up some of it for convenience.

07:39 <flux> performance can be 'good enough'

07:39 <flux> you just said you did some Ruby ;)

07:40 <fasta> flux: yes, and that was the convenience for library availability for small scripts which are I/O bound.

07:41 <companion_cube> OCaml can already give very good performance, assuming you don't need multicore

07:41 <fasta> I think if you do want multi-core performance, you need to design your datastructures very carefully anyway.

07:42 lggr has quit [Ping timeout: 268 seconds]

07:42 <companion_cube> or you can use some message passing

07:43 <fasta> companion_cube: I think if your message passing implementation can receive messages in parallel, there isn't much of a problem.

07:44 <fasta> (and you have to send messages asynchronously, of course)

07:44 hkBst has quit [Ping timeout: 246 seconds]

07:45 <flux> in the end it's always (nowadays) message passing performed with the cache coherency protocol ;)

07:45 <fasta> flux: exactly.

07:45 <flux> but I suppose the message passing primitives programming languages provide are nowhere near as low-level - or efficient

07:45 <fasta> A 'signal' is basically a message.

07:46 <fasta> Modern hardware architectures are going to expose message passing.

07:46 edwin has joined #ocaml

07:46 <fasta> (I recently saw a presentation about some experimental piece of hardware which had a lot less caches or even none at all)

07:46 edwin has left #ocaml []

07:47 <fasta> They wanted to see what the performance hit was.

07:47 <companion_cube> then it would be great for ocaml to provide a simple, standard way of exchanging messages between processes

07:47 <flux> intel has this 64-core thing that has no cache coherency

07:47 <fasta> flux: yeah, that's what I meant.

07:47 <fasta> companion_cube: JoCaml basically already does this.

07:48 <fasta> I am not sure whether you can also use JoCaml as a library.

07:48 hkBst has joined #ocaml

07:48 <fasta> I.e., without writing in JoCaml syntax.

07:49 <flux> afaiu you can use libraries written in jocaml from ocaml-programs

07:50 <flux> but otherwise, no idea

07:51 lggr has joined #ocaml

07:52 hkBst has quit [Ping timeout: 246 seconds]

07:53 hkBst has joined #ocaml

07:53 hkBst has quit [Changing host]

07:53 hkBst has joined #ocaml

07:54 <companion_cube> fasta: I'm not sure JoCaml supports effectively multicore

07:57 ontologiae has joined #ocaml

07:58 <fasta> companion_cube: it just runs multiple processes.

07:58 lggr has quit [Ping timeout: 264 seconds]

07:59 <fasta> companion_cube: http://jocaml.inria.fr/pub/joex/ray/README

07:59 <fasta> companion_cube: example

07:59 <companion_cube> oh, it does? nice

08:00 <fasta> companion_cube: of course, that's ray-tracing, which is kind of a stupid benchmark.

08:00 <fasta> companion_cube: (because there's almost no communication)

08:00 <fasta> It would be more interesting to see a linear amount of communication.

08:01 <companion_cube> well then, they should merge JoCaml into OCaml :)

08:01 <fasta> It wouldn't surprise me if that would happen at some point.

08:01 <fasta> It seems easy to maintain.

08:01 <flux> it would surprise me, at least if it would go as-is

08:02 <fasta> (two weeks after 4.00 was released, they released it)

08:02 <flux> it has at least one backwards-incompatible syntax change currently, the & operator (although it's been deprecated for ocaml for a while, so I suppose it wouldn't be that bad)

08:02 Cyanure has quit [Remote host closed the connection]

08:02 <fasta> It's also not really that interesting whether or not it is merged, since you can already use it.

08:02 hkBst has quit [Ping timeout: 264 seconds]

08:03 <flux> true

08:03 <flux> but then there are things like lwt, that could probably somehow work with it

08:03 lggr has joined #ocaml

08:03 <flux> ..and the new contender Async from Jane Street

08:04 <fasta> I wonder if Jane Street would want to switch to Haskell if some oracle came by to do it for free.

08:04 <fasta> I think they wouldn't want it.

08:06 Cyanure has joined #ocaml

08:07 hkBst_ has joined #ocaml

08:07 Cyanure has quit [Remote host closed the connection]

08:08 lggr has quit [Ping timeout: 246 seconds]

08:10 lggr has joined #ocaml

08:11 eikke has joined #ocaml

08:15 lggr has quit [Ping timeout: 246 seconds]

08:18 rgrinberg has quit [Ping timeout: 268 seconds]

08:19 hkBst_ has quit [Read error: Connection reset by peer]

08:20 hkBst_ has joined #ocaml

08:20 hkBst_ has quit [Changing host]

08:20 hkBst_ has joined #ocaml

08:20 lggr has joined #ocaml

08:25 lggr has quit [Ping timeout: 240 seconds]

08:32 lggr has joined #ocaml

08:36 lggr has quit [Ping timeout: 244 seconds]

08:42 lggr has joined #ocaml

08:47 lggr has quit [Ping timeout: 248 seconds]

08:54 lggr has joined #ocaml

08:59 hkBst_ has quit [Read error: Connection reset by peer]

08:59 hkBst_ has joined #ocaml

08:59 hkBst_ has quit [Changing host]

08:59 hkBst_ has joined #ocaml

09:00 lggr has quit [Ping timeout: 260 seconds]

09:01 lggr has joined #ocaml

09:06 lggr has quit [Ping timeout: 248 seconds]

09:14 lggr has joined #ocaml

09:21 lggr has quit [Ping timeout: 268 seconds]

09:26 lggr has joined #ocaml

09:33 lggr has quit [Ping timeout: 245 seconds]

09:39 lggr has joined #ocaml

09:42 Yoric has quit [Ping timeout: 246 seconds]

09:43 lggr has quit [Ping timeout: 244 seconds]

09:44 hkBst_ has quit [Remote host closed the connection]

09:44 eni has joined #ocaml

09:44 hkBst_ has joined #ocaml

09:46 lggr has joined #ocaml

09:51 lggr has quit [Ping timeout: 245 seconds]

09:55 hkBst_ has quit [Read error: Connection reset by peer]

09:56 hongboz has quit [Ping timeout: 240 seconds]

09:57 hkBst_ has joined #ocaml

09:58 lggr has joined #ocaml

10:05 lggr has quit [Ping timeout: 252 seconds]

10:05 hkBst_ has quit [Remote host closed the connection]

10:08 hkBst_ has joined #ocaml

10:08 hkBst_ has quit [Changing host]

10:08 hkBst_ has joined #ocaml

10:11 lggr has joined #ocaml

10:15 lggr has quit [Ping timeout: 246 seconds]

10:20 Yoric has joined #ocaml

10:21 lggr has joined #ocaml

10:25 lggr has quit [Ping timeout: 252 seconds]

10:33 lggr has joined #ocaml

10:40 lggr has quit [Ping timeout: 256 seconds]

10:43 ankit9 has joined #ocaml

10:45 lggr has joined #ocaml

10:51 lggr has quit [Ping timeout: 246 seconds]

10:56 chambart has quit [Ping timeout: 245 seconds]

10:57 lggr has joined #ocaml

10:58 _andre has joined #ocaml

11:04 lggr has quit [Ping timeout: 240 seconds]

11:09 lggr has joined #ocaml

11:10 eni has quit [Ping timeout: 248 seconds]

11:16 lggr has quit [Ping timeout: 248 seconds]

11:16 eikke has quit [Ping timeout: 268 seconds]

11:22 lggr has joined #ocaml

11:28 Tobu has quit [Ping timeout: 272 seconds]

11:29 lggr has quit [Ping timeout: 256 seconds]

11:29 Snark has joined #ocaml

11:29 Tobu has joined #ocaml

11:34 lggr has joined #ocaml

11:41 Kakadu has joined #ocaml

11:41 lggr has quit [Ping timeout: 245 seconds]

11:43 ftrvxmtrx has quit [Quit: Leaving]

11:45 ftrvxmtrx has joined #ocaml

11:47 lggr has joined #ocaml

11:47 CrazyThinker has joined #ocaml

11:50 chambart has joined #ocaml

11:54 lggr has quit [Ping timeout: 268 seconds]

11:59 lggr has joined #ocaml

12:03 lggr has quit [Ping timeout: 246 seconds]

12:12 lggr has joined #ocaml

12:12 eikke has joined #ocaml

12:13 ftrvxmtrx has quit [Ping timeout: 268 seconds]

12:13 Drakken has quit [Ping timeout: 268 seconds]

12:16 lggr has quit [Ping timeout: 252 seconds]

12:24 lggr has joined #ocaml

12:25 Drakken has joined #ocaml

12:27 ftrvxmtrx has joined #ocaml

12:28 lggr has quit [Ping timeout: 240 seconds]

12:34 lggr has joined #ocaml

12:35 fraggle_laptop has quit [Remote host closed the connection]

12:39 fraggle_laptop has joined #ocaml

12:40 lggr has quit [Ping timeout: 260 seconds]

12:41 eikke has quit [Ping timeout: 264 seconds]

12:46 lggr has joined #ocaml

12:50 lggr has quit [Ping timeout: 246 seconds]

12:53 rothwell has joined #ocaml

12:53 <rothwell> 'lo. what is the compiler trying to tell me here? http://pastebin.ca/2206252

12:53 Drakken has quit [Ping timeout: 256 seconds]

12:54 gnuvince has joined #ocaml

12:54 ftrvxmtrx has quit [Quit: Leaving]

12:54 <rothwell> those two look the same modulo α-conversion, to me...

12:55 <flux> you need to put one argument back in

12:55 <flux> due to support for mutable values

12:55 <flux> let from_list x = ... x

12:56 eni has joined #ocaml

12:56 <flux> '_a is the type variable to look for

12:56 lggr has joined #ocaml

12:57 <rothwell> hm, yes, that works... not sure i really understand why

13:01 lggr has quit [Ping timeout: 246 seconds]

13:05 Drakken has joined #ocaml

13:07 lggr has joined #ocaml

13:11 lggr has quit [Ping timeout: 264 seconds]

13:17 lggr has joined #ocaml

13:19 eni has quit [Ping timeout: 264 seconds]

13:22 lggr has quit [Ping timeout: 240 seconds]

13:23 eikke has joined #ocaml

13:27 matthiasgorgens has joined #ocaml

13:28 lggr has joined #ocaml

13:28 gnuvince has quit [Ping timeout: 256 seconds]

13:30 gnuvince has joined #ocaml

13:32 lggr has quit [Ping timeout: 252 seconds]

13:33 Kakadu has quit [Quit: Page closed]

13:36 eni has joined #ocaml

13:39 <thelema> rothwell: if it were not required, you would be able to break type safety through mutable values

13:40 lggr has joined #ocaml

13:41 <rothwell> thelema: is there a specific example of that somewhere? i'm curious

13:43 <flux> yes.. but not sure where, and it always takes a while to whip up the example :)

13:43 <thelema> rothwell: let f = let x = ref [] in fun y -> x := y :: !x

13:44 <thelema> the right hand side is a value, and not syntactically a function

13:44 NaCl is now known as SpanishInquisitr

13:44 <thelema> so the ocaml type system does not give it full polymorphism, only limited polymorphism, with a type to be determined when it's used.

13:45 <thelema> "it" is the function f

13:45 <rothwell> hm, i see

13:45 <thelema> only syntactic functions can be fully polymorphic

13:46 <thelema> and... well, some values...

13:46 paolooo has joined #ocaml

13:46 <thelema> like []

13:46 <flux> the rule could probably be enhanced to be less restrictive, but as it is, it's pretty easy to understand

13:47 lggr has quit [Ping timeout: 240 seconds]

13:47 <thelema> and pretty easy to deal with

13:47 <f[x]> http://stackoverflow.com/q/4242677/118799

13:50 lggr has joined #ocaml

13:54 lggr has quit [Ping timeout: 240 seconds]

14:00 lggr has joined #ocaml

14:02 ankit9 has quit [Quit: Leaving]

14:04 lggr has quit [Ping timeout: 248 seconds]

14:07 smondet has joined #ocaml

14:12 lggr has joined #ocaml

14:13 hkBst_ has quit [Quit: Konversation terminated!]

14:14 avsm has joined #ocaml

14:19 lggr has quit [Ping timeout: 246 seconds]

14:24 gnuvince has quit [Ping timeout: 240 seconds]

14:25 lggr has joined #ocaml

14:32 lggr has quit [Ping timeout: 260 seconds]

14:34 gnuvince has joined #ocaml

14:38 lggr has joined #ocaml

14:40 CrazyThinker has left #ocaml []

14:43 lggr has quit [Ping timeout: 252 seconds]

14:47 paolooo has quit [Quit: Page closed]

14:51 lggr has joined #ocaml

14:52 rgrinberg has joined #ocaml

14:58 lggr has quit [Ping timeout: 268 seconds]

14:59 munga has joined #ocaml

14:59 <munga> why Hashtbl.hash always returns the same value if I pass a record to it ?

15:00 <munga> ignore my question ...

15:00 <munga> buaaa.

15:00 munga has quit [Client Quit]

15:00 <thelema> :)

15:01 lggr has joined #ocaml

15:05 lggr has quit [Ping timeout: 264 seconds]

15:10 lggr has joined #ocaml

15:14 lggr has quit [Ping timeout: 256 seconds]

15:17 avsm has quit [Ping timeout: 252 seconds]

15:19 Cyanure has joined #ocaml

15:19 lggr has joined #ocaml

15:22 ocp has left #ocaml []

15:24 lggr has quit [Ping timeout: 268 seconds]

15:28 lggr has joined #ocaml

15:30 eikke has quit [Ping timeout: 256 seconds]

15:31 mika1 has quit [Quit: Leaving.]

15:32 cago has quit [Quit: Leaving.]

15:32 lggr has quit [Ping timeout: 246 seconds]

15:33 Snark has quit [Quit: Quitte]

15:37 Tobu has quit [Ping timeout: 260 seconds]

15:38 lggr has joined #ocaml

15:43 lggr has quit [Ping timeout: 256 seconds]

15:50 lggr has joined #ocaml

15:55 lggr has quit [Ping timeout: 246 seconds]

16:01 lggr has joined #ocaml

16:05 lggr has quit [Ping timeout: 268 seconds]

16:07 avsm has joined #ocaml

16:07 Yoric has quit [Ping timeout: 245 seconds]

16:10 lggr has joined #ocaml

16:11 Tobu has joined #ocaml

16:13 avsm has quit [Quit: Leaving.]

16:13 err404 has quit [Remote host closed the connection]

16:14 lggr has quit [Ping timeout: 240 seconds]

16:15 ulfdoz has joined #ocaml

16:20 Tobu has quit [Ping timeout: 260 seconds]

16:20 lggr has joined #ocaml

16:21 Tobu has joined #ocaml

16:23 cdidd has joined #ocaml

16:25 lggr has quit [Ping timeout: 246 seconds]

16:29 chambart has quit [Ping timeout: 246 seconds]

16:31 lggr has joined #ocaml

16:31 rgrinberg has quit [Ping timeout: 244 seconds]

16:35 lggr has quit [Ping timeout: 260 seconds]

16:37 ontologiae has quit [Ping timeout: 246 seconds]

16:38 sepp2k has quit [Ping timeout: 246 seconds]

16:39 sepp2k has joined #ocaml

16:40 lggr has joined #ocaml

16:44 osa1 has joined #ocaml

16:45 djcoin has quit [Quit: WeeChat 0.3.7]

16:46 lggr has quit [Ping timeout: 268 seconds]

16:52 lggr has joined #ocaml

16:52 paolooo has joined #ocaml

16:56 avsm has joined #ocaml

16:57 avsm1 has joined #ocaml

16:57 avsm has quit [Read error: Connection reset by peer]

16:59 lggr has quit [Ping timeout: 246 seconds]

17:02 lggr has joined #ocaml

17:05 eni has quit [Ping timeout: 244 seconds]

17:06 lggr has quit [Ping timeout: 246 seconds]

17:07 everyonemines has quit [Quit: Leaving.]

17:14 lggr has joined #ocaml

17:14 Yoric has joined #ocaml

17:15 thomasga has quit [Ping timeout: 248 seconds]

17:21 gnuvince has quit [Ping timeout: 245 seconds]

17:21 lggr has quit [Ping timeout: 268 seconds]

17:23 fraggle_laptop has quit [Remote host closed the connection]

17:23 lggr has joined #ocaml

17:28 lggr has quit [Ping timeout: 248 seconds]

17:28 diego_diego has joined #ocaml

17:29 sepp2k has quit [Ping timeout: 264 seconds]

17:29 diego_diego has quit [Read error: Connection reset by peer]

17:30 diego_diego has joined #ocaml

17:30 diego_diego has quit [Client Quit]

17:34 SpanishInquisitr is now known as NaCl

17:34 sepp2k has joined #ocaml

17:34 Tobu has quit [Ping timeout: 272 seconds]

17:35 lggr has joined #ocaml

17:36 Tobu has joined #ocaml

17:41 Tobu has quit [Ping timeout: 260 seconds]

17:42 lggr has quit [Ping timeout: 264 seconds]

17:45 lggr has joined #ocaml

17:49 lggr has quit [Ping timeout: 246 seconds]

17:49 emmanuelux has joined #ocaml

17:55 lggr has joined #ocaml

17:59 dsheets has joined #ocaml

18:00 lggr has quit [Ping timeout: 244 seconds]

18:02 pangoafk is now known as pango

18:06 lggr has joined #ocaml

18:14 lggr has quit [Ping timeout: 260 seconds]

18:16 lggr has joined #ocaml

18:20 sgnb has quit [Remote host closed the connection]

18:20 sgnb has joined #ocaml

18:20 lggr has quit [Ping timeout: 264 seconds]

18:22 osa1 has quit [Ping timeout: 246 seconds]

18:28 lggr has joined #ocaml

18:31 edwin has joined #ocaml

18:35 lggr has quit [Ping timeout: 240 seconds]

18:38 lggr has joined #ocaml

18:38 edwin has quit [Remote host closed the connection]

18:39 edwin has joined #ocaml

18:42 lggr has quit [Ping timeout: 256 seconds]

18:46 err404 has joined #ocaml

18:47 lggr has joined #ocaml

18:48 Sablier_ has joined #ocaml

18:50 eudicot has quit [Ping timeout: 245 seconds]

18:50 eudicot has joined #ocaml

18:51 <thelema> are there any experts on library link flags embedded in .cmxa files awake?

18:52 lggr has quit [Ping timeout: 248 seconds]

18:52 <thelema> My problem is with mlpcap; the .cma file has linking options built into it, but the cmxa file - nothing

18:54 <thelema> hmm, do .cmxa files even have this information built into them ever? bitstring is the same way...

18:54 edwin has left #ocaml []

18:55 <thelema> my root problem is a linking error - undefined references to symbols defined in the dllpcap_stubs.so file

18:55 <thelema> this file is installed in a directory in ocaml's ld.conf file

18:56 Sablier_ has quit [Ping timeout: 265 seconds]

18:57 lggr has joined #ocaml

19:01 lggr has quit [Ping timeout: 264 seconds]

19:07 sepp2k has quit [Read error: Connection reset by peer]

19:07 lggr has joined #ocaml

19:11 hongboz has joined #ocaml

19:14 lggr has quit [Ping timeout: 260 seconds]

19:17 lggr has joined #ocaml

19:21 lggr has quit [Ping timeout: 260 seconds]

19:23 eni has joined #ocaml

19:24 pngl has joined #ocaml

19:26 <pngl> I'm new to Ocaml. I've seen people on emacs get a printout of the value of every line of a file whenever they do C-x C-b (I think). Is it possible to get the same result through a command-line tool?

19:26 lggr has joined #ocaml

19:27 <thelema> pngl: hmm, you can paste a file into the toplevel

19:27 ghostbuster2 has joined #ocaml

19:27 <thelema> pngl: run 'ocaml' and put your code into it, followed by ;;

19:28 <pngl> thelema: thank you

19:29 <thelema> ot make the toplevel easier to use (since it doesn't come with line editing), use 'rlwrap ocaml'

19:30 <wmeyer> pngl: M-x tuareg-run-ocaml RET

19:30 <wmeyer> pngl: or even way better: M-s utop RET

19:30 lggr has quit [Ping timeout: 246 seconds]

19:30 <wmeyer> M-x

19:31 <wmeyer> If you've installed ocaml from ocamlbrew utop come out of the box

19:31 <wmeyer> just as it is.

19:31 <wmeyer> now, if you don't use ocamlbrew than I would suggest trying it out :-)

19:32 * thelema realizes that ocamlbrew is the first ocaml platform

19:33 <pngl> wmeyer: doesn't your advice presuppose emacs?

19:33 <wmeyer> thelema: indeed, today? :-) waaa

19:33 <wmeyer> pngl: yes, it factly it does

19:34 <thelema> wmeyer: for some reason, I was still awaiting someone to make an ocaml platform.

19:34 Yoric has quit [Ping timeout: 245 seconds]

19:34 <wmeyer> pngl: I know ther are vim users, and still the workflows are different

19:34 <pngl> wmeyer: I'm one of them :

19:34 <pngl> wmeyer: :)

19:35 oriba has joined #ocaml

19:35 <wmeyer> thelema: no worries, we are getting there. Still we have to work hard ;-)

19:35 <wmeyer> pngl: YEAH!

19:35 <wmeyer> :-)

19:35 lggr has joined #ocaml

19:36 <wmeyer> thelema: it was long time ago recognised, we need it, but once we have the needed rudimentary tools and environment we can keep doing it.

19:37 <ghostbuster2> hello, any ideas to setup ocaml to work in a window split with vim?

19:37 <pngl> (If someone has a little script that feeds every line of a file to the toplevel so I don't have to write it myself, I'll be ever thankful)

19:37 <thelema> ghostbuster2: just running 'ocaml' inside vim doesn't work?

19:37 <wmeyer> pngl: press C-c e

19:37 <wmeyer> pngl: preassuming tuareg mode, or typerex

19:38 <thelema> wmeyer: stop trying to convert the vi user to emacs

19:38 <wmeyer> pngl: these days i think my mode is tuareg, it sucks a lot of less battery

19:38 <wmeyer> thelema: ups

19:38 <pngl> wmeyer: I'll learn emacs one day, but not tonight

19:38 <wmeyer> pngl: ok, so my excitement was premature sorry

19:38 <thelema> pngl: I'm sure such a script exists, but don't know enough about the vi world to help

19:39 <ghostbuster2> thelema, E492: Not a editor command, !ocaml returns to bash.... I would like to have ocaml running in a split an a file in other...

19:39 lggr has quit [Ping timeout: 245 seconds]

19:40 <wmeyer> ghostbuster2: https://bitbucket.org/mmottl/vim-files/src/b527be0e38da/.vimrc

19:40 <wmeyer> (Markus Mottl uses vim AFAIK)

19:40 <wmeyer> dig his scripts, that can help you

19:42 <wmeyer> right, there are two major modes

19:42 Cyanure has quit [Remote host closed the connection]

19:42 <wmeyer> omlet.vim and ocaml.vim

19:42 <wmeyer> i can't advice

19:42 <wmeyer> what i read, omlet has better indentation

19:42 <wmeyer> (kill me if i am wrong)

19:43 <ghostbuster2> who's interested may want to use this http://www.vim.org/scripts/script.php?script_id=1196

19:43 <ghostbuster2> oh what a coincidence wmeyer

19:44 lggr has joined #ocaml

19:45 Sablier_ has joined #ocaml

19:45 <wmeyer> look at the date though

19:45 <hongboz> ghostbuster2: the official caml-mode is good enough

19:45 <wmeyer> it might not support things like local modules

19:45 <wmeyer> hongboz: so two of us?

19:45 <ghostbuster2> wmeyer, yeah, a little disappointing

19:46 <thelema> https://github.com/jrk/vim-ocaml

19:46 <wmeyer> hongboz: (convering vim users to emacs)

19:46 <hongboz> oh, sorry

19:46 <wmeyer> hongboz: help appreciated ;)

19:47 <wmeyer> actually i wanted to write some code

19:48 Sablier_ has quit [Client Quit]

19:48 <ghostbuster2> hongboz, the bug is not a easy one

19:49 Sablier_ has joined #ocaml

19:49 lggr has quit [Ping timeout: 248 seconds]

19:49 <ghostbuster2> thelema, many thanks for your link

19:52 <thelema> ghostbuster2: n/p

19:52 paolooo has quit [Quit: Page closed]

19:53 Yoric has joined #ocaml

19:56 lggr has joined #ocaml

19:58 Sablier_ has quit []

19:59 Sablier_ has joined #ocaml

20:00 Anarchos has joined #ocaml

20:00 <pngl> For whoever's interested: I went low-tech . I just edit in vim, then :w, Alt-Tab, C-p, RET with a readline-wrapped ocaml in another window and #use "myfile.ml";; as the last line.

20:01 lggr has quit [Ping timeout: 268 seconds]

20:02 <Anarchos> pngl i edit in vim too

20:06 lggr has joined #ocaml

20:08 chambart has joined #ocaml

20:08 ghostbuster2 has quit [Ping timeout: 264 seconds]

20:09 <Anarchos> chambart modulonet ? C'est marrant comme nom de réseau :)

20:10 lggr has quit [Ping timeout: 240 seconds]

20:10 <thelema> Anarchos: #ocaml-fr

20:10 <Anarchos> thelema oh sorry wrong language

20:11 <Anarchos> chambart fun as a network name, modulonet :)

20:13 Yoric has quit [Ping timeout: 260 seconds]

20:16 gnuvince has joined #ocaml

20:16 lggr has joined #ocaml

20:17 avsm1 has quit [Quit: Leaving.]

20:21 lggr has quit [Ping timeout: 246 seconds]

20:29 smondet has quit [Remote host closed the connection]

20:31 ontologiae has joined #ocaml

20:32 lggr has joined #ocaml

20:34 hongboz has quit [Ping timeout: 246 seconds]

20:37 avsm has joined #ocaml

20:39 lggr has quit [Ping timeout: 256 seconds]

20:42 lggr has joined #ocaml

20:43 avsm has quit [Quit: Leaving.]

20:44 <pngl> I want to capture two possible constructors of a recursive type t in one expression (to make pattern matching easier). Is that possible? (e.g. type t = C1 of string | C2 of C1, and I want an expression that matches "C1 of string" and "C2 C1 of string")

20:45 <thelema> | C1 s | C2 (C1 s) -> ... s ...

20:45 <Anarchos> thelema you were faster than me :)

20:46 <thelema> this time.

20:46 <pngl> Ah I can match multiple types on the left of -> ! :-) thank you.

20:46 avsm has joined #ocaml

20:46 lggr has quit [Ping timeout: 246 seconds]

20:47 <thelema> you can match multiple patterns, separated by | before one ->, but make sure that they all bind the same identifiers with the same types

20:47 <thelema> i.e. `| C1 s | C2 (C1 _) -> ...` is wrong

20:47 ontologiae has quit [Ping timeout: 268 seconds]

20:49 <pngl> Can I do | C1 s as x | C2 (C1 _) as x -> x ?

20:49 <thelema> | (C1 _) as x | C2 ((C1 _) as x) -> x

20:49 <thelema> maybe some of the parens aren't needed

20:49 <pngl> but both are of type t

20:49 <thelema> but you can't bind s in one pattern and not in the other

20:50 <pngl> sure

20:50 chambart has quit [Ping timeout: 246 seconds]

20:50 <pngl> thanks!

20:50 <thelema> n/p

20:50 ontologiae has joined #ocaml

20:50 chambart has joined #ocaml

20:52 eni has quit [Quit: Leaving]

20:57 lggr has joined #ocaml

21:02 avsm has quit [Quit: Leaving.]

21:04 lggr has quit [Ping timeout: 246 seconds]

21:07 lggr has joined #ocaml

21:12 lggr has quit [Ping timeout: 264 seconds]

21:16 lggr has joined #ocaml

21:21 lggr has quit [Ping timeout: 256 seconds]

21:27 wmeyer has quit [Remote host closed the connection]

21:28 lggr has joined #ocaml

21:32 lggr has quit [Ping timeout: 240 seconds]

21:34 <pngl> Going back to my earlier question, I'm pattern matching on a pair. Each member can be one of 3 patterns. Is there something more elegant than writing 3² lines?

21:35 <thelema> do you have 9 -> results?

21:35 <pngl> no, one

21:36 <thelema> you can use | in the middle of patterns

21:36 <thelema> | (A | B | C), (A | B | C) -> ...

21:36 <thelema> i gotta go; Anarchos - it's all you

21:38 <pngl> oh yes. perfect. Alright, where should I read up on this so I don't have to ask here next time? Also, out of curiosity, is it possible to define an expression that will expand to a pattern? e.g. exp = A | B | B; and then | (exp, exp) -> ...;; ?

21:38 lggr has joined #ocaml

21:39 <pngl> thelema: thanks!

21:40 <Anarchos> pngl you can't define patterns as furst class values

21:41 err404 has quit [Remote host closed the connection]

21:41 <Anarchos> cause the name is bound to the values while applying the pattern matching

21:41 ontologiae has quit [Ping timeout: 264 seconds]

21:41 avsm has joined #ocaml

21:43 gnuvince has quit [Ping timeout: 246 seconds]

21:43 <pngl> I don't follow

21:43 avsm1 has joined #ocaml

21:43 gnuvince has joined #ocaml

21:43 lggr has quit [Ping timeout: 264 seconds]

21:45 wmeyer has joined #ocaml

21:45 avsm has quit [Ping timeout: 245 seconds]

21:47 lggr has joined #ocaml

21:51 oriba has quit [Quit: oriba]

21:52 lggr has quit [Ping timeout: 248 seconds]

21:53 <pngl> Anarchos: couldn't the string of the pattern be interpolated at compile time?

21:56 lggr has joined #ocaml

21:56 CoverSlide has joined #ocaml

22:01 lggr has quit [Ping timeout: 256 seconds]

22:01 _andre has quit [Quit: leaving]

22:05 lggr has joined #ocaml

22:10 lggr has quit [Ping timeout: 256 seconds]

22:14 lggr has joined #ocaml

22:15 <Anarchos> pngl try to do : let fun x => let p = A|B in match x with p -> 0 | _ -> 1;;

22:16 <Anarchos> pngl i get syntax error on A|B

22:16 <Anarchos> patterns can't be used to defined values as p

22:18 lggr has quit [Ping timeout: 240 seconds]

22:25 lggr has joined #ocaml

22:29 lggr has quit [Ping timeout: 245 seconds]

22:37 lggr has joined #ocaml

22:41 lggr has quit [Ping timeout: 240 seconds]

22:42 Anarchos has quit [Quit: Vision[0.9.7-H-090423]: i've been blurred!]

22:47 lggr has joined #ocaml

22:52 lggr has quit [Ping timeout: 256 seconds]

22:56 lggr has joined #ocaml

23:00 lggr has quit [Ping timeout: 246 seconds]

23:06 lggr has joined #ocaml

23:07 ftrvxmtrx has joined #ocaml

23:08 chambart has quit [Ping timeout: 244 seconds]

23:11 lggr has quit [Ping timeout: 248 seconds]

23:18 lggr has joined #ocaml

23:22 ftrvxmtrx has quit [Quit: Leaving]

23:24 lggr has quit [Ping timeout: 256 seconds]

23:30 lggr has joined #ocaml

23:31 chambart has joined #ocaml

23:35 lggr has quit [Ping timeout: 256 seconds]

23:39 lggr has joined #ocaml

23:42 emmanuelux has quit [Remote host closed the connection]

23:43 lggr has quit [Ping timeout: 260 seconds]

23:50 Sablier_ has quit []

23:51 serialk has left #ocaml []

23:54 lggr has joined #ocaml

23:56 chambart has quit [Ping timeout: 246 seconds]

23:58 lggr has quit [Ping timeout: 246 seconds]