lamawithonel has quit [Read error: Connection reset by peer]
Associat0r has quit [Quit: Associat0r]
<astory>
It looksl ike sets don't have a map operation in the standard library; do I need to define it myself or am I just not seeing it?
ymasory has quit [Quit: Leaving]
<orbitz>
astory: no, since it could produce a new set type
<orbitz>
which woul dbe a different module
<orbitz>
if the type or values change
<astory>
yeah, I realize that after I wrote my fold to do job. I don't think you could do it under ocaml's type system in a good way
lopexx has quit [Ping timeout: 246 seconds]
lopex has joined #ocaml
<thelema>
astory: batteries' polymorphic set has both map and filter_map
avsm has quit [Quit: Leaving.]
myu2 has joined #ocaml
myu2 has quit [Remote host closed the connection]
flx__ has joined #ocaml
lopex has quit []
flux has quit [Ping timeout: 260 seconds]
flx__ is now known as flux
mjonsson has joined #ocaml
<mjonsson>
I wrote a very basic lexer and parser using ocamllex and ocamlyacc. It seems to work but when i want to use it interactively reading from stdin it seems that something is getting buffered somewhere so parse results don't come in until i hit ctrl-d to send EOF on stdin
jlouis has quit [*.net *.split]
fabjan has quit [*.net *.split]
mcclurmc has quit [*.net *.split]
StepanKuzmin has quit [*.net *.split]
Obfuscate has quit [*.net *.split]
joewilliams has quit [*.net *.split]
Derander has quit [*.net *.split]
StepanKuzmin has joined #ocaml
Obfuscate has joined #ocaml
joewilliams has joined #ocaml
Derander has joined #ocaml
Stepan_Kuzmin has joined #ocaml
fabjan has joined #ocaml
mcclurmc has joined #ocaml
jlouis has joined #ocaml
StepanKuzmin has quit [Remote host closed the connection]
mfp has quit [Ping timeout: 246 seconds]
mfp has joined #ocaml
<thelema>
mjonsson: lex/yacc don't generally work well from stdin...
<thelema>
I don't think there's any easy way to flush their buffers...
<mjonsson>
okay
<mjonsson>
i wonder how ocaml does its repl then
<mjonsson>
maybe it's not even using lex/yacc
avsm has joined #ocaml
avsm has quit [Client Quit]
avsm has joined #ocaml
eye-scuzzy has quit [Quit: leaving]
eye-scuzzy has joined #ocaml
eye-scuzzy has quit [Client Quit]
astory has left #ocaml []
scooty-puff has joined #ocaml
<scooty-puff>
i was considering working on ocamldefun, however, the pages mentioned in any posts seem to be inactive
<scooty-puff>
so i was planning on writing it from scratch
<mjonsson>
(actually all i was missing was flush stdout in my loop)
<scooty-puff>
my plan was to use camlp4 and the bytecode representation, which would require that the user compile to bytecode, then the bytecode to machine code
<scooty-puff>
does seem make sense?
<scooty-puff>
*does this seem to make sense?
<scooty-puff>
or better yet, is there a noninternal representation of bytecode or the il?
ymasory has joined #ocaml
emmanuelux has quit [Remote host closed the connection]
avsm has quit [Quit: Leaving.]
arubin has joined #ocaml
myu2 has joined #ocaml
Stepan_Kuzmin has quit [Remote host closed the connection]
<kaustuv>
Ah, the old "if it runs on the JVM or .Net it must be ipso facto superior" argument.
<kaustuv>
I guess there is a certain breed of programmer who feels naked without their SingletonAbstractFactoryVisitorAdapter frameworks
<mrvn>
I would rather wait for proper libraries than have to use the crappy languages ones.
<mrvn>
and it's not like ocaml doesn't already have bindings for all the good libraries anyway.
<kaustuv>
One binding I wish was more standard, or at least better maintained, is to a modern OpenGL
<kaustuv>
as in, something more recent than the fixed function pipeline model in LablGL
<mrvn>
lablgl isn't?
<kaustuv>
lablgl can't do essentially anything past OpenGL 2.1. No shaders, for one.
<Associat0r>
kaustuv: well the thing is F# got me into .NET not the other way around
<kaustuv>
note, I have been quite happy with glMLite, but unfortunately it is GPLv3, i.e., toxic to anything outside of academia
<Associat0r>
what I actually want is a OCaml/Scala like language with a transparent cost model
<mrvn>
I kind of like GPLv3 for the patent clause and anti-tivo clause.
<mrvn>
and I hate libs/modules that are only GPLv2 instead of "or later"
<kaustuv>
The patent clause is inapplicable to us in Europe anyway at least until the EU finally rams their software patent crap through in some non-democratic manner
<mrvn>
kaustuv: it protects us from patents in non-EU and if they screw up the patent law in EU it starts working there too. No harm, great benefit.
<kaustuv>
well, anyway, I keep hoping that all the commercial interest in OCaml will lead to a simplified BSD-like license for the OCaml runtime.
<kaustuv>
maybe dual licensed as BSD and LGPL2.1+LE
<kaustuv>
This might need to happen as a result of a wholesale replacement of the runtime, though
<adrien>
when a reddit comment takes all the space of your 1080 pixel-high screen with a small font, you know it's time to skip to the next one
<adrien>
kaustuv: what's the issue the ocaml runtime being lgpl+le?
<kaustuv>
the letters 'g', 'p' and 'l', mainly
SoftTimur has joined #ocaml
avsm has joined #ocaml
<SoftTimur>
Hello all, I would like to learn compilation coded in ocaml, could anyone suggest me some documents? my aim is to create a toy language (for instance, a simpler C or Java) in ocaml...
<orbitz>
What does it mean when people say objects aren't composable?
<orbitz>
Does it mean that there is no operator I can define that meaningfully does let o3 = compose o1 o2?
<mrvn>
SoftTimur: have you done any compiler building?
<mrvn>
orbitz: what would that even mean?
<SoftTimur>
mrvn: not really
<rproust>
SoftTimur: speaking french? check out universities from Paris that have compiler courses and get the student project done
<SoftTimur>
rproust: how do you know I speak french?
<rproust>
whois
<mrvn>
SoftTimur: I suggest you start with general compiler building theory and the examples for streams, parser, lexer in the ocaml manual.
<orbitz>
mrvn: It sounds like, for some methods you can come up with a meaningful thing, but I'm not sure what it means for data or other methods
<mrvn>
orbitz: Maybe the composition of 2 objects should then again be an object with that method. But I don't see why you couldn't write something like that.
<kaustuv>
SoftTimur: read the book "Modern Compiler Implementation in ML" by Appel. It's in Standard ML, which is fairly close to OCaml.
<mrvn>
SoftTimur: ever used scheme? If you want to start simple I would write a compiler for that.
<kaustuv>
Note that compiling functional languages is generally an order of magnitude more complex than compliting procedural languages.
<mrvn>
kaustuv: not really.
<orbitz>
kaustuv: only if you want it to run in any reasonable amount of time
<mrvn>
kaustuv: the oppsoite in fact I would say.
<SoftTimur>
mrvn: I have already read the the part in ocaml manual, so I am looking for some "general compiler building theory". As everything is coded in ocaml here, I would prefer something in ocaml...
<mrvn>
SoftTimur: we had a university course for that. We did a subset of ocaml for powerpc.
<SoftTimur>
mrvn: do you have any link?
<mrvn>
SoftTimur: I'm afraid not. that was 10 years ago.
<kaustuv>
mrvn: with due respect, you are saying something absurd. A compiler for a functional language has to do everything one for a procedural does, and in addition deal with higher order features (closure conversion, CPS/A-normal form transform, some kind of inlining, etc.)
rproust has quit [Quit: Changing server]
bnwr has joined #ocaml
bnwr has quit [Client Quit]
<mrvn>
kaustuv: You don't need closures, higher order functions, inlining, ...
<kaustuv>
I would say then that you aren't compiling a functional language
rproust has joined #ocaml
<mrvn>
And with imperative languages you first need to transform to single asignment or cps or so.
<adrien>
kaustuv: lgpl+le and gpl are quite different and I don't think people want to change the (small) stdlib very often
<orbitz>
Some peopel consider JavaScript to be functional so might want ot be careful about what ou're actually debating
<mrvn>
kaustuv: We did a subset of ocaml. Only toplevel recrusive functions and no type inference and such.
<kaustuv>
orbitz: Some people consider shit gold. I am talking about sensible definitions of "functional", not what delusions Joe Reddituser suffers from
<mrvn>
I'm not sure if we had higher order functions
<orbitz>
kaustuv: Hah, well speicifcaly I've heard JS being a funcitonal language form Don Stewart
<mrvn>
orbitz: well, it functions, doesn't it. :)))))
<orbitz>
kaustuv: JS is an extreme example. I'm just saying to be sure you two are debating teh same thing
<mrvn>
kaustuv: do you consider scheme functional?
<kaustuv>
I am not interested in bikeshedding about what "functional" means. I am talking about the issues in compiling an ML-like language.
<mrvn>
kaustuv: well, I'm not. :)
<mrvn>
compare a "a simpler C or Java" to a "simpler (oca)ml".
<orbitz>
See, that's why I said you guys should be sure you're talking abotu the same thing
<orbitz>
:)
<mrvn>
I would never start with a full ML-like language as my first try into building a compiler. way too much theory to grasp.
lopex has quit []
<orbitz>
One of my planned projects is subset of Python -> Ocaml compiler
<kaustuv>
If that is what you mean, then you shouldn't say things like "the opposite in fact". It gives the impression that you think compiling ML is easier than compiling C, when you actually mean that a lobotimized ML that basically looks like C is easy to write a compiler for
<kaustuv>
that should have said mrvn: at front
<mrvn>
kaustuv: I assumed you got that from context. :) anyway, we all know what we mean now. lets get back to something usefull.
<orbitz>
You ever drink Baileys from a shoe?
<mrvn>
*urgs* and have it taste like feet and ruin the shoe?
<SoftTimur>
guys, so I am going to attack "modern compiler implementation in ml", hope it is very close to ocaml...
<mrvn>
But thanks for reminding me. I have some Baileys left that will go bad soon. Better drink it.
<orbitz>
SoftTimur: The Little MLer has a cheat sheet for SML -> Ocaml
Cyanure has quit [Remote host closed the connection]
<SoftTimur>
orbitz: sorry, I do not see what you mean...
<orbitz>
SoftTimur: the book The Little MLer has a cheat shit for common syntax differences between SML and Ocaml
<mrvn>
SoftTimur: in case you have problems translating the SML examples into ocaml.
<orbitz>
cheat sheet*
<orbitz>
(I'm guessing the book recommended to you is in SML)
<thelema_>
Associat0r: on cost models: if you want to run on x86, your cost model is near useless
<kaustuv>
Associat0r: I would say that knowing when something is a value type is *far* more transparent in OCaml than in some of the other MLs
<Associat0r>
kaustuv: no it's not
<Associat0r>
kaustuv: F# gives you total control over that for example
<kaustuv>
Ah, you mean that the programmer should be able to define arbitrary structs. Obviously, OCaml has no support for that
<kaustuv>
(structs used in the same sense as C)
ygrek has joined #ocaml
thelema has joined #ocaml
ttamttam has quit [Quit: ttamttam]
<mrvn>
kaustuv: everything is a value. what is there to know? :)
ttamttam has joined #ocaml
<kaustuv>
By the way, having arbitrary value types actually compliates the cost model. You never know the cost of an assignment without knowing the type of the content of the location. In OCaml, all assignments are "constant" (as in constant overhead over GC)
<thelema>
Associat0r: ah, you mean something different from me when you say "cost model", you really mean "user-defined data layout"
<thelema>
I'm all in favor of the second - see Ada for a language that gives the user *great* control over this.
<Associat0r>
thelema: I should have said, representation control
<kaustuv>
You can't do that without keeping some type information at runtime, and you probably will also need to allow pointer inside blocks which complicates GC quite a bit
<thelema>
Associat0r: yup, in that case, I agree with you - OCaml doesn't give the user the level of control over representation that would be nice.
<Associat0r>
thelema_: IIRC OCaml had a noalloc kinda thing
<thelema_>
just for external functions
<Associat0r>
ah ok
* thelema_
wonders if ocaml would benefit from a "pragma(pure)" declaration on modules so that unreferenced pure modules could be dropped
dnolen has quit [Quit: dnolen]
<adrien>
until you start using unpure functions from other modules
<Associat0r>
thelema_: did you see Harrop's HLVM project?
<thelema_>
a pure module would have no side effects on being loaded - would only declare functions and maybe values requiring no computation
<thelema_>
Associat0r: yes, I know of HLVM
<Associat0r>
thelema_: what's your opinion on it?
<kaustuv>
thelema_: would you consider this module "pure"? module M = struct let x = while true do () done end
<thelema_>
kaustuv: no
rien has quit [Ping timeout: 276 seconds]
<thelema_>
maybe only defining functions and literal values
<thelema_>
Associat0r: ambitious, but not usable yet, and not high enough on my priorities to put work into
<mrvn>
thelema_: It could even define values that require computations if they have no side effects
<thelema_>
Associat0r: it's got potential for high speed work
<kaustuv>
If that's your definition of "pure", then surely a pragma is not necessary. It seems like a manifestly inferrable attribute
<thelema_>
kaustuv: okay, too restrictive. maybe mrvn's 'no side effect' definition is better
<kaustuv>
again, does the M module qualify as "no side effects"?
<thelema_>
kaustuv: I wouldn't consider your example pure, as there'd be a visible difference between linking it and not linking it
<mrvn>
module M : sig val get_x : unit -> int end = struct let x = ref 0; let _ = incr x; let get_x () = !x; end would still be pure.
<kaustuv>
incidentally, you would need to have an entry point (i.e., a particular main()) in order to detect unused modules.
<mrvn>
If get_x isn't used then the computation of x is irelevant.
<thelema_>
a pure module that's not referenced from any other module could still be dropped even without a main()
<mrvn>
kaustuv: because otherwise all modules might be unused and droped?
<mrvn>
I would claim that the main module can not be pure.
<thelema_>
well, if all your modules were pure, they all could be dropped, as they'd have no side effect
<mrvn>
and if your main() function has no side effects then whats the point of running your code in the first place?
<thelema_>
exactly
<kaustuv>
thelema_: that's a pretty notion of "unused", unless you want the module gc run to be iterated. Imagine a tree of module dependencies. You can kill the root in the first iteration of detecting "unreferenced" modules, but then you have to keep running it on the new roots of the dependency dag.
<kaustuv>
err, s/tree/dag/
<kaustuv>
and "pretty weak"
<mrvn>
kaustuv: a module is unsued if none of its functions is called. A module is pure if it itself is pure and all modules it calls are pure too.
<thelema_>
kaustuv: gc starting at the leaves
<mrvn>
Or better: A tree of modules can be dropped if the root is unused and all its modules are pure.
<thelema_>
err, n/m
<kaustuv>
but the leaves *are* presumably referenced by something
<kaustuv>
mrvn: you mean that a module can be dropped if *all* its parents in the dependency dag are unreferenced
<mrvn>
Or better: The root of a tree of modules can be dropped if the root is unused and all its modules are pure.
<thelema_>
ok, each module is a root, and gc starting at them, removing modules that are pure and have no references
avsm has quit [Quit: Leaving.]
<mrvn>
kaustuv: roots have no parents
<kaustuv>
yes, but you said "a tree can be dropped". What if some of the modules lower in the tree are referenced from a path not coming from the root in question?
bzzbzz has joined #ocaml
<mrvn>
kaustuv: yes, only the root can be dropped. Then you need to repeat for the new roots.
<kaustuv>
which is exactly what I already said
<mrvn>
Imho the problem is detecting when a module is pure in the first place. A 'let x = while true do ()' makes a module unpure and then you have the halting problem.
<SoftTimur>
hello, I just borrowed the book, started to read it... thanks all
<mrvn>
Or let _ = Printf.printf "Hello world\n"
<mrvn>
but not let hello_txt = Printf.printf "Hello, this is version %s\n"
<thelema_>
mrvn: thus annotations. If the user gets it wrong, linking in modules for the side effect of loading them fails. big deal.
<mrvn>
yep.
<mrvn>
Maybe the attribute should be allowed for values too. No need to include functions that aren't used.
<rproust>
mrvn: in js_of_ocaml, there's a dead code elimination step that removes unused functions
<thelema_>
mrvn: that's the next step
<rproust>
(so that you don't get the full List module when calling (@))
<kaustuv>
definitely dead *function* elimination seems like something that should be trivial to add to the current batch of OCaml compilers in a weekend
<thelema_>
it'd require rewriting .cmxes
<kaustuv>
(note, I have no clue how difficult it is, but on the internet no one knows that you are clueless)
<thelema_>
since there's no whole-program compilation step, just linking
<thelema_>
rproust: hmm, can you tell what the roots are?
<kaustuv>
maybe dead function elimination is not so trivial actually if the module initializer touches all module entries
Poet_ has joined #ocaml
<rproust>
thelema_: it's a .cma -> js compiler so the whole structure is there
<thelema_>
rproust: I was just hoping you were more familiar with the code than I could be in 30 seconds
<thelema_>
rproust: no problem
<rproust>
thelema_: I've used the compiler but haven't hacked/tweaked it
<rproust>
there's a presentation on the ocamlmeeting about it
<thelema_>
again I wish I could go
hangs has joined #ocaml
<hangs>
hi -- sorry to ask a newbie question (is that ok?) how do a create an efficient set of strings from a file that can be looked up easily? i've been trying Set.Make but unable to understand the syntax
<rproust>
hangs: set of strings? those strings being the lines of the file?
<hangs>
yes
<hangs>
rproust: thanks
<hangs>
rproust: yes, they are just one string per line... i need to read another file and check each string for membership in the first file (efficiently)
<thelema_>
hangs: a trie would be good
<thelema_>
type 'a trie = Node of bool * 'a trie array | Leaf of bool
<hangs>
thelema_ : is this inbuilt? i prefer to use something already there... i just want the equiv of Set.add(line) and Set.contains(s) in java
<thelema_>
hangs: no, you'd have to define it
<hangs>
i don't even need the ordering
<thelema_>
if you're happy using sets, do: module StringSet = Set.Make(String)
<rproust>
hangs: I would use Lwt_io.read_lines and Lwt_stream.fold. But I guess I'm Lwt obsessed and Idk what you mean by efficient…
<hangs>
can't i use the Set.Make etc? i've been trying tht for an hour but no luck with the syntax
<thelema_>
and use StringSet.add, find
<kaustuv>
module S = Set.Make (String)
<kaustuv>
let set_of_lines ls = List.fold_left (fun s l -> S.add l s) S.empty ls
ymasory_ has joined #ocaml
<hangs>
kaustuv: i don't need all the lines, just need to check for membership (we can eliminate dups in the set)
<thelema_>
hangs: sets do that automaticaly
<rproust>
hangs: it seems that sets are exactly what you need
<rproust>
it should fit your requirement
<rproust>
+s
<hangs>
thanks folks, let me try out that syntax
<thelema_>
hangs: make sure to get the capitalization right
<SoftTimur>
mrvn: "int[][][] x = new int[2][][];" seems to work in my code
<thelema_>
mrvn: java. heh
thomasga1 is now known as thomasga
robinnn has quit [Quit: Leaving]
ulfdoz has joined #ocaml
ftrvxmtrx has joined #ocaml
<SoftTimur>
thanks all
<avsm>
folks, we haven't had any applications for Google Summer of Code for ocaml-related Xen projects. One idea (SSL) is here, but others also welcome http://wiki.xensource.com/xenwiki/GSoC_2011_ideas
<avsm>
If you're interested, mail me an outline asap at anil@recoil.org ; be a pity not to get free money out of google :)
<avsm>
deadline is quite soon
<mrvn>
What has ocaml got to do with xen?
ygrek has joined #ocaml
<mrvn>
Should we write ocaml bindings for libvirt?
<mrvn>
Or an xen based OS in ocaml?
<avsm>
i'm more interested in improvements for Mirage (which has a Xen microkernel backend)
<avsm>
but there are a lot of potential interesting projects in the Xen Cloud Platform in general
avsm has quit [Quit: Leaving.]
<thomasga>
mrvn: XCP is written in ocaml
pdhborges has joined #ocaml
<pdhborges>
has anyone used polymorphic variants for flag arguments
<thelema_>
it scales past 2 without exponential growth
Yoric has joined #ocaml
<thelema_>
you lose a tiny bit of efficiency, but it's rarely a problem
<pdhborges>
yes but the I have to scan a list each time the function is used
<pdhborges>
a ok
<pdhborges>
I'm using the poly vars
<pdhborges>
because variants reserve the type constructors names
<pdhborges>
and there are more uses for a similar flag
Snark has quit [Quit: Ex-Chat]
<thelema_>
sure. Just be careful with the types.
<thelema_>
and typos, which will result in amazing error messages that have only a typo's worth of difference
<pdhborges>
ok
<pdhborges>
^^
thelema has joined #ocaml
<mrvn>
Mirage is cool.
<mrvn>
Does it support multiple cores or multiple threads?
<mrvn>
concurrent threads that is
thelema_ has quit [Ping timeout: 240 seconds]
<hcarty>
mrvn: Have you watched the tech talk on Mirage?
<mrvn>
no. Is there one that doesn't need flash?
<hcarty>
The talk is informative, and the project is cool
<hcarty>
I have an mp4 somewhere...
<hcarty>
Which was from a legitimate source. I just don't remember which.
<adrien>
(if needed, I can rehost one too)
<hcarty>
Oh, it looks like avsm has left. I'm happy to provide it, but I want to make sure it's ok to do so.
<mrvn>
I found a paper in pdf. That is probably good enough.
srcerer has quit [Quit: ChatZilla 0.9.86 [Firefox 3.6.16/20110319135224]]
<mrvn>
Mirage looks like exactly what I would have done to make an ocaml kernel.
<thelema>
wow, that's creepy - google just informed me that someone I follow in twitter tweeted about mirage.
Yoric has quit [Quit: Yoric]
<adrien>
=)
<adrien>
you have to love google's (near) real-time update from twitter, pastebin.com and others
_andre has quit [Quit: leaving]
_andre has joined #ocaml
<mrvn>
FYI the Mirage kernel runs a single ocaml thread with the Lwt module for async I/O. Multiple cores are to be used by running multiple VMs.
<mrvn>
Would be nice to have multitasking so one can run multiple ocaml progs in parallel on one VM. Each task could have its own GC with some shared memory extention to handle UPC.
<mrvn>
IPC.
<mrvn>
Anyone interested in implementing that here is your chance. Make a GSOC project. :)
<hcarty>
mrvn: I think that's one of the projects the OCamlPro folk(s) are talking about implementing
<thomasga>
I am not the one who call them microkernels and I am not from the OS community, but I believe, the name comes from this paper
<thomasga>
actually, I am not sure to know the real definition, I'll read wikipedia :-)
<mrvn>
thomasga: so you mean Mirage is a process for the xen mikrokernel?
<thomasga>
a mirage application is a virtual machine
<thomasga>
with no OS
<mrvn>
a blindingly simple kernel by design.
Yoric has joined #ocaml
pdhborges has quit [Ping timeout: 252 seconds]
avsm has joined #ocaml
enthymeme has joined #ocaml
avsm has quit [Client Quit]
HoraseLunums has joined #ocaml
srcerer has joined #ocaml
hangs has joined #ocaml
<hangs>
hi, using ocaml 3.12. is there something like Java's String.startsWith() ?
<thelema>
hangs: not built in - it's a one line function to do inefficiently
<hangs>
and btw, is there a good tutorial of the form "ocaml for java programmers"... sorry to be asking newbie questions
<hangs>
thelema: ok thanks
<thelema>
a mapping from the JVM standard library to all the ocaml libraries out there would be a very large task
<hcarty>
hangs: Have you seen the (old but still useful) O'Reilly book, or the Cal Tech book? Both are reasonable, although probably not oriented toward Java folks specifically.
<hcarty>
hangs: The Cal Tech book by Jason Hickey has a nice chapter which focuses on a comparison between OO-based and module-based approaches to problems, for example.
<ygrek>
extlib has String.starts_with
<hcarty>
Batteries seems to as well
<hcarty>
Likely directly from extlib
<thelema>
Batteries should have everything in extlib (except the compression module), if not, it's a bug
ulfdoz has quit [Read error: Operation timed out]
_andre has quit [Quit: leaving]
enthymeme has quit [Quit: rcirc on GNU Emacs 23.1.1]
Yoric has quit [Quit: Yoric]
<hangs>
hcarty: i can't install camomile
<hangs>
ocamlfind install camomile $files META camomileLibrary.mli camomileLibraryDefault.mli camomileLibraryDyn.mli camomileLibrary.cmi camomileLibraryDefault.cmi camomileLibraryDyn.cmi ocamlfind: camomileLibraryDyn.cmi: No such file or directory
<hangs>
(on the way to installing batteries)
<hangs>
any ideas?
<hangs>
this is on os x 10.6
<thelema>
hangs: [./configure] and [make] completed successfully?
<hangs>
is there a precompiled binary/installer for batteries for osx?
<hangs>
yes
<thelema>
hangs: I'm working on an auto-installer for ocaml packages, but it's in a broken state at the moment
<thelema>
ah, the Dyn files aren't there on osx?
<thelema>
well, it should work without them
<hangs>
ok waitasec... sorry i hadn't typed make... went staight to make install
<thelema>
aha
<thelema>
apparently make install doesn't depend on make. bad camomile
<hangs>
unfortunately, can't link batteries even after installing camomile, ounit etc.
<hangs>
cp -f src/batCamomile-0.8.1.ml src/batCamomile.ml test ! -e src/batteries_config.ml || rm src/batteries_config.ml ocamlbuild syntax.otarget byte.otarget src/batteries_help.cmo META shared.otarget Finished, 1 target (0 cached) in 00:00:00. Warning: tag "package" does not expect a parameter, but is used with parameter "str" + ocamlfind ocamlopt -shared -linkall -package camomile,num,str -o src/batteries_uni.cmxs src/batteries_uni.cmxa ld:
<hangs>
(sorry): here is the relevant part: ld: absolute addressing (perhaps -mdynamic-no-pic) used in _caml_curry13 from src/batteries_uni.cmxs.startup.o not allowed in slidable image. Use '-read_only_relocs suppress' to enable text relocs collect2: ld returned 1 exit status
<hcarty>
hangs: I don't use OSX, but I think there was something on either the GODI or main OCaml mailing list about this. Which version of OCaml are you using?
<thelema>
maybe you can turn off shared libraries?
<thelema>
BATTERIES_NATIVE_SHLIB = no make
<thelema>
also, send me the output of uname -s so I can fix this automatically
<thelema>
ah, you're not using the git version - it autodetects darwin now.
<thelema>
and turns off shared library building automatically
<thelema>
gotta go for a while, back later
thomasga has quit [Quit: Leaving.]
winterc has joined #ocaml
winterc has quit [Client Quit]
SoftTimur has quit [Quit: Leaving.]
enthymeme has joined #ocaml
jamii has quit [Ping timeout: 240 seconds]
pdhborges has joined #ocaml
ygrek has quit [Ping timeout: 246 seconds]
<hangs>
(back from lunch) hcarty: ocaml 3.12. same error w/ BATTERIES_NATIVE_SHLIB = no
<hangs>
uname -s : Darwn
<hangs>
sorry, Darwin
<hangs>
thelema: pls see above
<hangs>
(g2g for a meeting)
ymasory has quit [Quit: Leaving]
edwin has quit [Remote host closed the connection]
hangs has quit [Ping timeout: 252 seconds]
enthymeme has quit [Quit: bounce]
enthymeme has joined #ocaml
marchdown_ has joined #ocaml
marchdown has quit [Ping timeout: 276 seconds]
marchdown_ is now known as marchdown
<pdhborges>
sometimes I'm envious of haskell's type system lol. Is this normal?
<hcarty>
pdhborges: Take two module systems and call #ocaml in the morning?
<thelema>
pdhborges: maybe - just treat type classes as objects and it'll go away
<pdhborges>
Hahaha
<pdhborges>
hcarty: if I take 2 more modules my brain will just explode by having to litter the code with srtruct end and sig ends
adlsaks has quit [Ping timeout: 258 seconds]
HoraseLunums has quit [Remote host closed the connection]
lopex has joined #ocaml
Associat0r has quit [Ping timeout: 246 seconds]
ikaros has quit [Quit: Leave the magic to Houdini]
Amorphous has quit [Read error: Operation timed out]
hangs has joined #ocaml
emmanuelux has quit [Quit: =>[]]
Amorphous has joined #ocaml
emmanuelux has joined #ocaml
<hangs>
hi, i have a question on string compare. if i use "ac" = "ac", it says true. but also says true for "ac" != "ac" (!)