flux changed the topic of #ocaml to: Discussions about the OCaml programming language | http://caml.inria.fr/ | OCaml 4.00.1 http://bit.ly/UHeZyT | http://www.ocaml.org | Public logs at http://tunes.org/~nef/logs/ocaml/
ollehar has quit [Ping timeout: 276 seconds]
avsm has quit [Quit: Leaving.]
gnuvince- has quit [Ping timeout: 268 seconds]
ben_zen has quit [Quit: dinner]
wormphlegm has quit [Ping timeout: 264 seconds]
wormphlegm has joined #ocaml
q66 has quit [Quit: Leaving]
madroach has quit [Ping timeout: 264 seconds]
madroach has joined #ocaml
meretrix has joined #ocaml
dsheets has quit [Ping timeout: 268 seconds]
gnuvince- has joined #ocaml
gnuvince- has quit [Changing host]
gnuvince- has joined #ocaml
travisbrady has joined #ocaml
<watermind> are local exceptions available in OCaml these days?
introom has joined #ocaml
travisbrady has quit [Quit: travisbrady]
gautamc has quit [Read error: Connection reset by peer]
ygrek has joined #ocaml
introom has quit [Remote host closed the connection]
darkf has joined #ocaml
introom has joined #ocaml
Drup has quit [Quit: Leaving.]
<flux> watermind, there are local modules which can define exceptions (and the types of the exceptions can depend on the function parameter types)
ygrek has quit [Ping timeout: 264 seconds]
<watermind> flux: oh I see
ygrek has joined #ocaml
<watermind> flux: the philosophy seems to be "use modules, whenever you want to limit the scope of something"... I've seen them used for instance to localy open other modules
ygrek has quit [Ping timeout: 245 seconds]
Dodo has joined #ocaml
Dodo has quit [Remote host closed the connection]
ygrek has joined #ocaml
<flux> I think it's more like 'hey, we already have this syntax, so if we do it this way we need to introduce the minimal amount of new syntax'
<flux> which I can agree with. it keeps the language small(er).
introom has quit [Remote host closed the connection]
LimitSupremum has joined #ocaml
watermind has quit [Quit: Konversation terminated!]
Kakadu has joined #ocaml
ben_zen has joined #ocaml
introom has joined #ocaml
introom has quit [Ping timeout: 245 seconds]
LimitSupremum has quit [Quit: Leaving.]
<ygrek> gasche, please use "$@" instead of $* in opam-compiler-conf.sh
ygrek has quit [Remote host closed the connection]
weie_ has joined #ocaml
ygrek has joined #ocaml
weie has quit [Ping timeout: 260 seconds]
<adrien> I can't remember: what's the different between $@ and $* btw?
ben_zen has quit [Ping timeout: 245 seconds]
ben_zen has joined #ocaml
ben_zen_ has joined #ocaml
ben_zen_ has quit [Client Quit]
Simn has joined #ocaml
ben_zen has quit [Ping timeout: 276 seconds]
shinnya has quit [Ping timeout: 264 seconds]
ollehar has joined #ocaml
Kakadu has quit [Ping timeout: 240 seconds]
<ygrek> "$@" and $*
<ygrek> in short: the first one preserves quoted arguments, the second one doesn't
introom has joined #ocaml
introom has quit [Remote host closed the connection]
fmardini has joined #ocaml
introom has joined #ocaml
yezariaely has joined #ocaml
ulfdoz has joined #ocaml
* whitequark sighs
<whitequark> so it seems there is actually no way to write a menhir parser with internal state
<whitequark> what I essentially want is to add a field to _menhir_env
Kakadu_ has joined #ocaml
ggole has joined #ocaml
ggole has quit [Client Quit]
Kakadu_ has quit [Remote host closed the connection]
tane has joined #ocaml
Kakadu has joined #ocaml
ggole has joined #ocaml
<flux> hmm
<flux> I haven't used it for a while, but can't you just pass it around?
<flux> or maybe I don't understand your problem.
<flux> whitequark, so maybe: rule(_menhir_env): | BLAH { _menhir_env + 1 } ?
<whitequark> that's only for types
<whitequark> I solved (fsvo solved) my problem by building a closure in each reduction rule, and then expanding it all in the topmost one
<whitequark> so like: a=expr PLUS b=expr { fun env -> (a env) + (b env) }
<whitequark> I'm not very delighted by this solution
<flux> I was probably thinking of the lexer generator then
<ggole> That looks pretty strange
<ggole> What's the goal, to pass an argument in?
<whitequark> ggole: yes
<ggole> Ugh :/
<flux> I don't think it looks -that- bad, though :)
<whitequark> flux: this leads to 80% of code in my parser being boilerplate.
<whitequark> not very good.
<whitequark> what I want is to parse a description of a huge data structure (basically, interpreter heap), which can be thought of as one giant letrec definition
<whitequark> so I need state
<whitequark> in order to resolve references
<whitequark> and I want to do all this in single pass from within a parser, without a separate AST, because it (still) seems to me as a simpler, easier to maintain solution
<whitequark> I wanted to use a separate IrParserState module with a bit of global state, but the fun env -> thingy is cleane.r
<whitequark> it really is a pity that you cannot write stateful parsers in menhir.
<flux> ocamldoc seems to use ugh global state
<flux> so there clearly is a need for that feature :)
<whitequark> I imagine it'd be easy to do something like "type _menhir_env = { ...; state : '_a }"
<flux> hmm, is it that easy? what if it needs to do backtracking?
<flux> or is _menhir_env already in some stack
<whitequark> LR(1) doesn't
<flux> ah, ok
<whitequark> well, there are lookahead actions
<whitequark> but it's a really obscure and rarely needed feature
<whitequark> so if you just know about it, you probably know how to not shoot yourself :)
<whitequark> (and it seems that I indeed need this feature...)
<whitequark> ah, no, lazy evaluation works just as well.
<flux> so how does your solution finally look like?
<whitequark> wait a bit, I'll finish and verify it
introom has quit [Remote host closed the connection]
Kakadu has quit []
* whitequark wonders if it's possible to construct a closure environment which refers to itself
<adrien> you mean, an object?
<whitequark> hm?
<whitequark> I'm worrying about weird circular definitions
<whitequark> oh. yes, it is entirely possible to construct what I'm worrying about
<whitequark> not necessarily with closures. any two mutually recursive entities suffice.
* whitequark sighs
introom has joined #ocaml
q66 has joined #ocaml
ygrek has quit [Ping timeout: 264 seconds]
contempt has quit [Ping timeout: 245 seconds]
ulfdoz has quit [Ping timeout: 264 seconds]
ollehar has quit [Ping timeout: 240 seconds]
<whitequark> hm, ocaml doesn't have apply ?
<whitequark> though. I don't know what type would it have.
<mrvn> let apply f x = f x?
<mrvn> whitequark: you need rectypes to have closures that refer to themself or you need to declare a recursive type in wrap them in that.
<whitequark> (let apply) that would be a partial application for functions with more than one argument
<whitequark> what I wanted is an apply function which accepts a tuple
<whitequark> but it's somewhat superfluous anyway.
<whitequark> (rectypes) yeah, already understood that.
<mrvn> let apply3 f (x,y,z) = f x y z? For that you have to declare one per number of arguments.
<whitequark> sure
<whitequark> my initial thought was that maybe ocaml has that in stdlib
<mrvn> makes no sense
<whitequark> hm?
<whitequark> why?
<mrvn> You usualy don't write your function to take seperate arguments if you want to call it with tuples and vice versa.
<whitequark> well... yeah. in fact I'm not sure why I initially wanted apply in first case
<whitequark> but then I was curious why it isn't there
<mrvn> In ocaml you can't write pythons def apply(f, *args): return f(*args)
* whitequark nods
<whitequark> the type system is not strong enough, right?
<mrvn> You could create a GADT as witness type to pin down the arity of a tuple and then write an apply with that.
avsm has joined #ocaml
Nahra has quit [Quit: leaving]
Nahra has joined #ocaml
ulfdoz has joined #ocaml
avsm has quit [Ping timeout: 264 seconds]
<whitequark> hm, I need help with a very weird bug.
<whitequark> I have a menhir-generated file: https://gist.github.com/whitequark/c6c20533763d67c03154
<whitequark> it breaks with:
<whitequark> File "src/ir/irParser.ml", line 2824, characters 2-5:
<whitequark> Parse error: [fun_def] expected after "fun" (in [expr])
introom has quit [Remote host closed the connection]
<whitequark> and syntax highlighting in my editor breaks somewhere around line 1057
<whitequark> which may or may not be related, and I've no idea why
<whitequark> no, don't think highlighting is related. it simply has some kind of limit on the size of `let rec` it will highlight.
yacks has quit [Ping timeout: 264 seconds]
introom has joined #ocaml
<whitequark> -syntax(camlp4o) fixed it
Kakadu has joined #ocaml
<whitequark> SSA-on-a-chip ?
<pippijn> amongst other things
avsm has joined #ocaml
contempt has joined #ocaml
avsm has quit [Ping timeout: 276 seconds]
contempt has quit [Ping timeout: 264 seconds]
contempt has joined #ocaml
introom has quit [Remote host closed the connection]
<ggole> Not SSA, really: just SA
<ggole> No phis
<ggole> Gotta wonder how well it hides the latency of memory accesses though
<pippijn> whitequark: it's a FIFO queue instead of a stack or set of registers
<whitequark> I see
<whitequark> (haven't had a chance to watch the talk yet. it's also enormous.)
<pippijn> I'm watching it
<pippijn> it's worth watching
<pippijn> interestingly, the program controls the pipeline directly
introom has joined #ocaml
<whitequark> hm, won't that yield most of the same problems as VLIW?
mcclurmc has quit [Quit: Leaving.]
<pippijn> whitequark: I think so
<ggole> In terms of dependence on the compiler/details of the architecture? Yeah.
<pippijn> the program needs to know about all instruction latencies
<pippijn> the compiler
<pippijn> but I don't think that's so bad
<ggole> Apparently they have a "byte code" of sorts which is compiled for the specific machine at install time
<pippijn> hmm
avsm has joined #ocaml
<whitequark> interesting
<pippijn> compilers generally know about the latency of instructions, already
<whitequark> ^ yeah
<pippijn> they have a rough estimate of it
<pippijn> for instruction selection
<ggole> But you can still execute a poorly scheduled x86 program on any chip
osa1 has joined #ocaml
<whitequark> so this chip doesn't stall if the scheduling is wrong?
<pippijn> you can execute a poorly scheduled belt program, too
<whitequark> I imagine that's not very complex to implement
<ggole> If you get the scheduling wrong, the belt indexes/names will be wrong.
<ggole> If I understand this scheme correctly.
<pippijn> hmm
<whitequark> so values are pushed in the "order of arrival" ?
<pippijn> whitequark: yes
<whitequark> that sounds quite strange
<pippijn> ggole: it seems you're right
<whitequark> what if two values arrive simultaneously?
<ggole> That's why the compiler needs to know the *exact* latencies
<ggole> They drop to the belt at the same time
<whitequark> er
<ggole> (I'm not sure how order is determined)
<pippijn> I wonder in what order
<pippijn> probably in order of instruction reads
<ggole> The compiler needs to know to emit the right names, so it must be specified somehow
<ggole> I'm not sure how the varying latencies of the memory system are dealt with though
<ggole> Maybe they just give memory loads a long schedule and stall on them if they aren't done
<ggole> (That would really hurt.)
<whitequark> I imagine if you don't have a limited number of registers, you can hoist memory loads as far as possible
<ggole> But they do have a limited number? The size of the belt is 16 or 32 or something like that
<whitequark> oh.
<ggole> And there's a scratchpad
osa1 has quit [Quit: Konversation terminated!]
<whitequark> (16-32 belt size) I'm not sure how this differs from "canonical" RISCs then
<whitequark> well, it differs a bit, but not that much, it seems?
<ggole> I think the goal is to eliminate the need for renaming
<pippijn> ggole: yes
<pippijn> that's the goal
<ggole> That's why they have the single-assignment stuff
<ggole> Instead of a write to a register becoming a rename
<ggole> You just make a new name
ulfdoz has quit [Ping timeout: 245 seconds]
avsm has quit [Ping timeout: 264 seconds]
mcclurmc has joined #ocaml
<whitequark> Error: The record field label Rt.kClass belongs to the type Rt.roots but is mixed here with labels of type unit
<whitequark> labels of type unit ← what ?
<gasche> whitequark: you redefined `unit` locally?
avsm has joined #ocaml
bobry has quit [Quit: Connection closed for inactivity]
osa1 has joined #ocaml
<whitequark> gasche: no
<gasche> whitequark: then I'd be interested in a repro case
<whitequark> gasche: sadly there is a lot of code around this
<whitequark> oh.
<whitequark> I just realized.
<whitequark> nevermind, the type was inferred from another place to be `unit'
<whitequark> i.e. {} :> unit
<mrvn> interesting error
introom has quit [Remote host closed the connection]
<whitequark> mrvn: it's a parser. I used to have %start <unit> toplevel for testing the rules themselves
<whitequark> then I changed it to return the target structure itself but forgot about %start
<whitequark> or do you mean error message?
<mrvn> I ment the error message
<gasche> the error message could/should probably be improved, but I don't know how to reproduce it
<whitequark> type r = { foo : int };; let _ = ({ foo = 1; } : unit);;
<whitequark> that suffices
<mrvn> # type r = { foo : int };; let _ = ({ foo = 1; } : unit);;
<mrvn> type r = { foo : int; }
<mrvn> WTF?
<mrvn> It ignores everything after the first ;;
<whitequark> yeah, ;; = EOF
<whitequark> separate it in two inputs
<gasche> Error: This expression has type r but an expression was expected of type unit
dsheets has joined #ocaml
<whitequark> interesting
<whitequark> I have 4.00.1 here
<ggole> Error: The record field label foo belongs to the type r but is mixed here with labels of type unit
<gasche> it looks like it was a regression around 4.00.1
<gasche> neither my 3.12.1 nor trunk have this behavior
<ggole> 4.00.1 here too
<gasche> but I can reproduce it on 4.00.1
<ggole> Guess it got sorted out.
Patchou has quit [Read error: Connection reset by peer]
osa1 has quit [Remote host closed the connection]
osa1 has joined #ocaml
mcclurmc has quit [Ping timeout: 245 seconds]
dsheets has quit [Ping timeout: 240 seconds]
mcclurmc has joined #ocaml
Drup has joined #ocaml
<gasche> hum
<gasche> is someone here Goswin that just submitted a PR for "is mixed here with labels of type unit"?
<adrien> mrvn iirc
<gasche> ok
<adrien> gasche: ça met une minute au lieu de deux mais il bosse encore
<adrien> j'essaie sans mes modifs
<adrien> wrong chan :-)
weie has joined #ocaml
weie_ has quit [Ping timeout: 245 seconds]
shinnya has joined #ocaml
dsheets has joined #ocaml
<whitequark> ugh. I realized I hate ocaml's half-assed capitalization really bad
<whitequark> tempted to just start all my filenames with an uppercase letter
<whitequark> mainly because irEnvironment -> IrEnvironment = bad, and iREnvironment -> IREnvironment = also bad, and some files being capitalized and some not being capitalized is even worse.
fmardini has quit [Ping timeout: 268 seconds]
<adrien> well, you're free to do as you wish and mix as you wish
<pippijn> whitequark: yes, I have considered that, too
<pippijn> the advantage is that with ascii-compare, Makefile and stuff are on top
<pippijn> that's the main reason I haven't done it, yet
testcocoon has joined #ocaml
<ggole> Yeah, that took a bit of getting used to
<ggole> I still name files like-this.ml every now and then by accident and then get bitch slapped by the compiler
<whitequark> ha
<whitequark> Rails does the underscore/camelcase transformation, i.e. under_score -> Under
<whitequark> UnderScore and vice-versa
ben_zen has joined #ocaml
<whitequark> but it's only good if you want autoloading, since it transforms IRFoo -> ir_foo, ie, destructs info.
<whitequark> I'm honestly not sure how would I solve this problem except plain out naming stuff with their final names.
<whitequark> pippijn: _tags is on top either way :)
<whitequark> and I'm pretty sure this was the reason
<pippijn> yes, I think so
Kakadu has quit []
dsheets has quit [Ping timeout: 240 seconds]
dsheets has joined #ocaml
dsheets has quit [Ping timeout: 268 seconds]
dsheets has joined #ocaml
introom has joined #ocaml
<introom> would you give an example of let pattern = expression?
<pippijn> let [a; b; c] = [1; 2; 3]
<adrien> let (a, b, c) = (1, 2, 3)
<adrien> for one that won't throw a warning :-)
<introom> and let identifier pattern..pattern = expression?
<bernardofpc> why does it throw a warning ?
<pippijn> bernardofpc: the compiler emits a warning
<pippijn> because the pattern is refutable
<bernardofpc> I've seen it
<bernardofpc> but I don't get why
<pippijn> because let [a] = [] fails, for example
<bernardofpc> oh
<bernardofpc> right
<bernardofpc> it's a type stuff
<bernardofpc> [a] and [a;b;c] and [] have the same type
<bernardofpc> whereas (a,b,c) and (a) don't
<introom> bernardofpc: yeah.
<bernardofpc> let a,b,c = 1,2,3 ;; works
<bernardofpc> magic how OCalm gets rid of ()
<pippijn> that's not magic
<pippijn> that's just a parser thing
dsheets has quit [Ping timeout: 264 seconds]
<introom> what should a pattern match, the invoke args or the expression?
<introom> say, let identifier pattern..pattern = expression?
dsheets has joined #ocaml
<ggole> "Invoke args"?
<introom> let pattern = expression, seems the pattern matches the evaluation result of the expression
<introom> but what about let identifier pattern ..pattern = expression?
<pippijn> that's a function definition
<ggole> That's sugar for let ident = (fun ... -> ...)
<pippijn> let ident = fun pattern -> ... -> fun pattern -> expression
<ggole> And fun has basically the same matching as let
<introom> yeah. so the patten matches the invoking arguments
contempt has quit [Remote host closed the connection]
<introom> why does this fail? (fun (1 | 2) as i -> i + 1) 2
<Drup> fun don't do pattern matching, only "function" does
<flux> (fun ((1 | 2) as i) -> i + 1) 2
<flux> funs do pattern matching, but they don't do it for multiple distinct patterns with guard clauses
ygrek has joined #ocaml
ulfdoz has joined #ocaml
<introom> flux: what's guard clauses ?
<flux> match 42 with x when x = y -> ..
<introom> why the OCaml designers left out function matching?
<flux> function matching?
<ggole> You can't really inspect functions for structure
<ggole> (If that's what you meant.)
<introom> function has signature, like int -> int -> int = func
<ggole> That's not matching
<ggole> If you mean ascription, ocaml has that
<introom> can we match the function signatures?
<pippijn> introom: in what context?
<pippijn> you want to do type level pattern matching?
<ggole> No
<introom> yes.
<pippijn> no, you can't do that
<pippijn> because that would either need rtti (which ocaml doesn't have) or the function definition to be known at the call site
<pippijn> (which is most often not the case)
<introom> rtti?
<pippijn> runtime type information
dsheets has quit [Ping timeout: 240 seconds]
dsheets has joined #ocaml
<ousado> pippijn: thanks for the link, very interesting
ygrek has quit [Ping timeout: 245 seconds]
dsheets has quit [Ping timeout: 264 seconds]
dsheets has joined #ocaml
introom has quit [Remote host closed the connection]
dsheets has quit [Ping timeout: 264 seconds]
dsheets has joined #ocaml
mako has joined #ocaml
mako has quit [Read error: Connection reset by peer]
darkf has quit [Quit: Leaving]
dsheets has quit [Ping timeout: 264 seconds]
dsheets has joined #ocaml
ygrek has joined #ocaml
Nahra has quit [Ping timeout: 264 seconds]
ygrek has quit [Ping timeout: 240 seconds]
ollehar has joined #ocaml
<dsheets> grrr -classic-display
Kakadu has joined #ocaml
<dsheets> I am using Printexc.print_backtrace with a native code executable but nothing is printed. Suggestions on how to debug backtrace debugging? Everything is built with -g...
<rks`> are you running with OCAMLRUNPARAM=b ?
hto has joined #ocaml
<dsheets> rks`, i've tried both and it doesn't appear to have an effect. Also, I thought Printexc.print_backtrace works regardless?
MarcWebe1 is now known as MarcWeber
<dsheets> rks`, aha, you were right... a combination of using sudo and not passing OCAMLRUNPARAM
<adrien> you have to enable them first if not b
<dsheets> adrien, how's that?
<adrien> val record_backtrace : bool -> unit
<dsheets> gotcha... thanks
<adrien> Initially, backtraces are not recorded, unless the b flag is given to the program through the OCAML‐ RUNPARAM variable.
<dsheets> my stupid, it hurts
tane has quit [Quit: Verlassend]
ggole has quit [Ping timeout: 245 seconds]
<chris2> what do i need to take care of when using ocamlbuild with opam and ocaml core? i can "open Core.Std" everywhere except in a menhir header
<gasche> what's your OCaml version? there is a menhir-related bug that was fixed in trunk a few months ago
<chris2> The OCaml toplevel, version 4.00.1
<gasche> the workaround is to add the name of your menhir module in a "foo.mlypack" and build foo.cmo instead
<gasche> I think it works even if your file is foo.mly (that is, there should be no name conflict)
<gasche> (the workaround works because this bug was fixed a long time ago, but only partially, when compiling from a .mlypack and not from a .mly)
<chris2> i wonder why the depend step works
<gasche> ocamldep doesn't type-check files
<chris2> so i create a file parser.mlypack?
<gasche> yes
<gasche> with the content: "Parser\n"
<chris2> ok
<chris2> that works.
<gasche> .mlypack was originally meant to correspond to menhir's "modular composition of .mly files" feature, like .mllib or .mlpack
<chris2> almost...
<chris2> sigh
<chris2> now core clashes with the generated menhir code :P
<gasche> use a local open?
<gasche> you can even probably use
<chris2> i can't just hide "Error", can i?
<gasche> %{ include (struct open Core.std let ... end) %}
<gasche> probably not, chris2
<gasche> hm
<gasche> it may be possible to rebind exceptions
<gasche> exception E = Error;; open Core.Std; exception Error = E;;
<chris2> nope
<gasche> but I'm not sure ocaml will like having two declarations of Error in the same compilation unit
<gasche> local open is probably a better idea
<chris2> ok
<chris2> that mlypack fixed the bug in a different way
<chris2> weird :)
<chris2> there was a conflict between string and Core.Std.String.t
<chris2> which should be the same, anyway?
dsheets has quit [Ping timeout: 256 seconds]
<avsm> chris2: it's not a good idea to open Core.Std within the generated grammar at this time. we really need namespaces for that
<avsm> alternatively, if you insist :) you can end the header with "open Caml"
<avsm> that should reinstate the original Caml namespace
<avsm> from within Core.Std
Nahra has joined #ocaml
avsm has quit [Quit: Leaving.]
avsm has joined #ocaml
asmanur has joined #ocaml
leroux has quit [Quit: Goodbye.]
leroux has joined #ocaml
q66_ has joined #ocaml
<chris2> nasty: Random.self_init; vs Random.self_init (); :P
<adrien> :D
q66 has quit [Ping timeout: 240 seconds]
q66_ has quit [Ping timeout: 240 seconds]
avsm has quit [Quit: Leaving.]
ben_zen has quit [Ping timeout: 240 seconds]
<gasche> adrien: that's what -strict-sequence is about
<adrien> hmm?
<gasche> Random.self_init;
<adrien> (well, I think I understand but I'm not completely sure)
<adrien> it's not mentionned anywhere =/
<adrien> well, it(s in -h
dsheets has joined #ocaml
yezariaely has quit [Read error: Connection reset by peer]
yezariaely has joined #ocaml
hto has quit [Ping timeout: 264 seconds]
hto has joined #ocaml
asmanur has quit [Ping timeout: 264 seconds]
tane has joined #ocaml
dsheets has quit [Ping timeout: 240 seconds]
dsheets has joined #ocaml
<def-lkb_> avsm: "we really need namespaces for that"… do you have any idea when we can expect having namespaces?
<chris2> why is Core.Unix.chdir string -> unit?
<yezariaely> chris2: what did you expect?
<chris2> an error when the directory does not exist?
<yezariaely> hmm, true...
<chris2> or you are not allowed to enter
<chris2> int chdir(const char *path);
<chris2> exception Unix_error of error * string * string
<chris2> ah :)
<adrien> I think I prefer to have an exception for that
<chris2> yeah, perhaps better
tani has joined #ocaml
dsheets has quit [Ping timeout: 245 seconds]
dsheets has joined #ocaml
tane has quit [Ping timeout: 245 seconds]
pango__ has joined #ocaml
pango_ has quit [Ping timeout: 240 seconds]
Kakadu has quit []
Simn has quit [Quit: Leaving]
pango__ is now known as pango
hto has quit [Ping timeout: 276 seconds]
hto has joined #ocaml
dsheets has quit [Ping timeout: 264 seconds]
dsheets has joined #ocaml
<chris2> uh, match list with [a] -> ... | _ -> ... does the _ not match [] here?
<chris2> and why is that...
asmanur has joined #ocaml
<chris2> oh
<chris2> nvm
<chris2> i had an unclosed try..with in there :~
<dsheets> hmm sometimes Printexc.print_backtrace doesn't... or prints the backtrace from the previous exception
<dsheets> when I toggle with record_backtrace, the old backtrace disappears
travisbrady has joined #ocaml
dsheets has quit [Ping timeout: 276 seconds]
dsheets has joined #ocaml
q66 has joined #ocaml
dsheets has quit [Ping timeout: 245 seconds]
dsheets has joined #ocaml
dsheets has quit [Ping timeout: 245 seconds]
travisbrady has quit [Quit: travisbrady]
ulfdoz has quit [Ping timeout: 240 seconds]
contempt has joined #ocaml
osa1_ has joined #ocaml
osa1_ has quit [Client Quit]
osa1 has quit [Ping timeout: 264 seconds]
dsheets has joined #ocaml
avsm has joined #ocaml
yezariaely has quit [Quit: Leaving.]
osa1 has joined #ocaml
<chris2> i wonder if functional data structures result in fewer errors if you call them env, env', env'' ;)
osa1 has quit [Quit: Konversation terminated!]
iZsh has quit [Excess Flood]
iZsh has joined #ocaml
<mrvn> too much to type. v, v', v'', v'''
ollehar has quit [Ping timeout: 276 seconds]
<pippijn> ubuntu precise is a pain :(
<pippijn> there is no Core in precise
<mathieui> Ubuntu Precise Pain
osa1 has joined #ocaml
<pippijn> but I have to support it, since it's the LTS version
<pippijn> they only come out with a new one every 2 years :\
<pippijn> eabd4ac8 lwt/cohttp_lwt_unix.ml (Anil Madhavapeddy 2012-09-19 12:37:16 -0400 62) Lwt_stream.on_terminate stream (fun () ->
<pippijn> weird
<pippijn> I don't seem to have the on_terminate function
<pippijn> but it is documented
<pippijn> ah.. 2.4
tani has quit [Quit: Verlassend]
<pippijn> not even the latest ubuntu has 2.4
<pippijn> there is no way this code is going to work with 2.3 :\
contempt has quit [Quit: leaving]
contempt has joined #ocaml
ben_zen has joined #ocaml
Xom has joined #ocaml