nicoo has quit [Remote host closed the connection]
nicoo has joined #ocaml
Sorella has quit [Quit: Connection closed for inactivity]
tane has quit [Quit: Verlassend]
ygrek has joined #ocaml
_andre has joined #ocaml
CuriousErnestBro has joined #ocaml
sdothum has joined #ocaml
CuriousErnestBro has quit [Remote host closed the connection]
CuriousErnestBro has joined #ocaml
copy` has joined #ocaml
ygrek has quit [Ping timeout: 276 seconds]
tane has joined #ocaml
Mercuria1Alchemi has joined #ocaml
MercurialAlchemi has quit [Ping timeout: 265 seconds]
<orbitz>
In the immutable string world, what does the [] index operator mean? Do I need to do Bytes.set/Bytes.get for messing with bytes?
Algebr` has quit [Ping timeout: 244 seconds]
<companion_cube>
I think so
<orbitz>
Ok
<ggole>
With -safe-string, .[] won't work on a Bytes.t
pierpa has joined #ocaml
<orbitz>
I figured. Is there goign to change (or a new indexing operator added?)
<ggole>
I don't think so
haesbaert has joined #ocaml
<flux>
I guess one could be provided one on the Bytes module without breaking a lot of stuff
<flux>
though modular implicits will fix all this! I want to believe..
<ggole>
So you could Bytes.(b.[n])? That could work.
<companion_cube>
there was a proposal for overloadable .{}
<orbitz>
That'd be interesting
<companion_cube>
and .{} <-
<ggole>
Didn't that get used for BigArray?
<orbitz>
How serious is the modular implicits work? Is there a planned deliver time/
<flux>
no, there is no deliver time
<companion_cube>
yes, bigarray would just be one possible overloading
<flux>
I think there was/is a hiatus with some plans to carry on the development
<companion_cube>
no deliver time, but a brilliant PhD student, afaik :p
<flux>
but last I heard there might have been some issues (soundness?) that may not have been solved yet
<orbitz>
Who is the student?
<companion_cube>
def`, unless I'm mistaken
<orbitz>
I'm both excited and weary of modular implicits. Anythign "implicit" makes me weary.
<companion_cube>
flux: there need to be a proof of soundness, but I don't think they found a flaw yet?
<companion_cube>
well, clean overloading would still be tremendously useful :3
<companion_cube>
(give me Eq, Ord, and Show plz)
<flux>
I don't think anyone needs to make a proof, but at least a compelling argument ;-)
<companion_cube>
I think they want a proof
<orbitz>
companion_cube: yes it would be nice
<flux>
well, there goes one year then.. ;)
<flux>
though perhaps it wouldn't be horribly difficult
<orbitz>
It just also has a lot of potential for abuse
<flux>
the proof would be a translation from modular implicits to standard ocaml code, right?
<flux>
preferably code that is currently sound ;)
<flux>
it's a bit sad how there are these features in ocaml that don't quite work together that great
<flux>
GADT vs polymorphic variants, classes vs other recursive type definitions
<orbitz>
flux: liek what?
<orbitz>
ah
<flux>
I hope modular implicits won't join the camp.
<orbitz>
One thing I'm hopeing implicits gives us is more consistency in foundational types, like monad and applicative. I dislike all the convention around those.
<flux>
who are you kidding, we all just want a neat printing function ;-)
<orbitz>
ha, indeed
<flux>
it'll be a day when a newbie asks "how can I print this value?" "well, just use print value;;"
<companion_cube>
flux: no, a proof on the type-system level
<companion_cube>
oh, well, maybe it can be a translation to the current type-system
<companion_cube>
but on paper anyway
<flux>
is it going to be some phd thesis or something? a coq proof would certainly be applicable for one..
bobry has joined #ocaml
<Drup>
last I heard, the main problem with implicits was to actually implement it in the current typechecker
<flux>
hmm, it wasn't already? or does it take potentially unsound shortcuts?
<companion_cube>
I'm betting on def` implementing an equivalent of GHC Core, then the implicits on top of it
<companion_cube>
:3
d0nn1e has quit [Ping timeout: 240 seconds]
Mercuria1Alchemi has quit [Ping timeout: 265 seconds]
d0nn1e has joined #ocaml
rgrinberg has joined #ocaml
rgrinberg has quit [Quit: WeeChat 1.5]
rgrinberg has joined #ocaml
sh0t has joined #ocaml
al-damiri has joined #ocaml
cxii has quit [Quit: Page closed]
bruce_r has joined #ocaml
<zozozo>
is there a way to use ocamlbuild to generate .messages file using menhir's --list-errors option ?
<zozozo>
no, the --list-errors makes menhir outputs a list of the shortest path leading to errors states, in a format that allows you to write error messages for these states, so that you can use these messages when there is a parsing error
<zozozo>
in any case, I managed to do it by hand, ^^
larhat1 has quit [Read error: Connection reset by peer]
rgrinberg has quit [Ping timeout: 240 seconds]
larhat has joined #ocaml
ocaml080 has joined #ocaml
<ocaml080>
hello
<zozozo>
hi
<ocaml080>
I'm new to OCaml, can I get some help on some operator that I don't seem to understand?
<flux>
it basically means: take the left side, evaluate its value with Lwt, and pass it to the function on the right side, that as well returns a value that needs to be evaluated by Lwt
<Algebr`>
who has an example of static binding with ctypes and oasis/ocamlbuild?
<flux>
ocaml080, the type of >>= is: 'a Lwt.t -> ('a -> 'b Lwt.t) -> 'b Lwt.t
<flux>
so left side is the Lwt't value
<flux>
right side is the function that takes the value - but after Lwt has evaluated it - and returns a new value that's inside the domain of Lwt
<flux>
and finally the operator returns a the same value
<ocaml080>
is this something coming specifically from Lwt?
<flux>
in thise case yes
<flux>
but the same concept, and the same operator, is also used by other libraries
shinnya has joined #ocaml
tane has quit [Quit: Verlassend]
<flux>
you may find that the internet is filled with tutorials on the concept 'monad'
<flux>
it is called the monadic binding operator
<flux>
no such operator comes with the ocaml's standard library
ee_ks has joined #ocaml
ryanartecona has joined #ocaml
<flux>
ocaml080, more simply you can consider it (in this case) a sequencing operator for Lwt. first do this, then do that, and maybe use something that 'this' gave you to do it
<ocaml080>
flux: ok thank you very much, I will look into your explaination and also how to search for that operator helps alot as well.
<flux>
ocaml080, good luck!
<flux>
ocaml080, if you find struggling with the general monad concept, don't sweat it.. I think it can be used without deep understanding ;-).
<Algebr`>
okay ctypes with static binding is still very difficult to get going
<flux>
ocaml080, it seems also that once you understand it, you end up writing a tutorial on it.. you've been warned.
ee_ks has quit [Client Quit]
<ocaml080>
flux: haha thanks for the tip
<flux>
google "monad tutorial" -> 86900 results
<Algebr`>
and now giving up and going directly to the C ffi
<companion_cube>
careful to use Caml_params and Caml_return
<flux>
someone(TM) should really write a one-stop-solution where you write the stuff in one file, and then have a complete system WITH myocmalbuild.ml integration ;-), that gives you something that works ;)
<Algebr`>
I also don't understand what I stand to benefit from its use
<Algebr`>
and just spent some time using reason build stuff
<Algebr`>
all this build crap makes me want to scream in frustration.
<companion_cube>
me too, sometimes
<flux>
I thought the main point of salvuu is to get rid of _tags, and then perhaps avoid the interaction between myocamlbuild.ml and the _tags file. right?
<companion_cube>
flux: yeah
<companion_cube>
and write more readable rules, I think?
<flux>
I think I can say that the _tags file for that project lokos a bit stupid, could be more direct in the myocamlbuild.ml
<flux>
but I don't think switching to pure myocamlbuild.ml would reduce its size.. perhaps reduce the complexity a bit.
<smondet>
solvuu-build also gets rid of all the `.mllib` `.mlpack` crazyness
<flux>
does solvuu give any pre-built functions for making ie. a library out of .ml, .mli, and .c-files?
<smondet>
yes
<companion_cube>
hmm I think it has some basic rules? at least from the example I read
<flux>
with some custom libs?
<smondet>
see the example projects
<flux>
well, then I need to look into it :-)
<flux>
..though I just got that bit working!
<smondet>
biocaml is a pretty big project, it has C files, and uses solvuu-build
<flux>
I don't doubt it -can- do it, I mean ocamlbuild can as well :)
<smondet>
the myocamlbuild.ml is clearer than most _oasis files
<smondet>
out theree
<companion_cube>
I find _oasis files nice, but the problem is when it does not contain everything
bobry has quit [Quit: Connection closed for inactivity]
rgrinberg has joined #ocaml
<Algebr`>
smondet: bioocaml myocamlbuild still uses ocamlbuild
<Algebr`>
I'm having a lack of imagination as to what I'm gaining by using solvuu-build
<Algebr`>
besides no _tags
<companion_cube>
I guess it's less crazy than the regular myocamlbuild's rules
ocaml080 has quit [Quit: Page closed]
<smondet>
Algebr`: yes solvuu-build is a way of configuring ocamlbuild
<flux>
smondet, while I don't use it, I notice that the opam package is called solvuu_build
<flux>
I don't think that works with the sample mentioning opam config var solvuu-build:lib
<flux>
it = the package from direct opam, I just opam pin added solvuu-build so that works for me now
<smondet>
Algebr`: the default rules of ocamlbuild are crazy: zillions annoying files with custom DSLs + global state of tags difficult to manipulate
<flux>
also I was wondering might it be to work with ocamlfind instead of opam, it would be sort of lower level..
<smondet>
flux: the project was renamed (dash -> underscrore) I think a little ago, the README reflects master not the opam-repo (I think)
<flux>
smondet, ok, then that's fine :)
<flux>
I just thought there might be an oversight. bug even!
ryanartecona has joined #ocaml
<smondet>
then you can file issues :)
<flux>
well good I didn't ;-)
<profmaad>
is anybody familiar with combining camlp4 and ppx_tools.metaquot?
<profmaad>
camlp4 seems to be unwilling to parse the metaquot expressions as valid
<profmaad>
let stmt_id =
<profmaad>
else [%expr None] in
<profmaad>
then [%expr Some [%e AC.str id ]]
<profmaad>
if cacheable
<profmaad>
Parse error: [expr level top] expected after "then" (in [expr])
<flux>
hmm, I don't think you can combine camlp4 with ppx
<profmaad>
yeah, I don't really want to :D
<profmaad>
guess then what I really have is a built system issue
<profmaad>
this file uses a library that depends on lwt.syntax. Oasis generates ocamlbuild rules that pull in camlp4 for this file
<profmaad>
is there a way to tell ocamlbuild to please not use camlp4 for this?
<flux>
not sure actually if you can affect the _tags file that liberally with oasis.. ?
zpe has quit [Remote host closed the connection]
<flux>
there's something in the _tags file that says that some file requires campl4
<flux>
you would need to write it in such form that your file in question is excluded
<Algebr`>
companion_cube: can I break across lines somewhow in oasis
<flux>
I guess oasis just uses campl4 for everything
<Algebr`>
like for a super long CCOpt? Or define a variable in a _oasis file
<profmaad>
no, oasis only uses camlp4 when one of the dependencies says so
<profmaad>
its just a bit silly with how it deals with dependencies on libs in the same oasis file
<Algebr`>
oh this is new? findlib: [WARNING] While parsing '/Users/Edgar/.opam/objc/lib/ocp-index/META': Expected a '=' or a '(arguments,...)=' clause at line 2 position 37
rgrinberg has quit [Ping timeout: 276 seconds]
slash^ has joined #ocaml
<Algebr`>
hmm, okay utop has new intersting behavior...when doing #require "d" and any char in the quotes, it prints out a new line of this thing: ─( 09:02:11 )─< command 0 >──────────────────────────────────────{ counter: 0 }─
<companion_cube>
Algebr`: some lines are breakable, yes
<companion_cube>
especially lists
<companion_cube>
but globally I think that if you keep the lines indented, it's parsed as one block
<Algebr`>
lists I knew were breakable, but I want to break on CCOpt
<companion_cube>
the possible issue is if oasis gives a multiline option to the compiler :/
rgrinberg has joined #ocaml
<Leonidas>
companion_cube: I wonder whether the authors of Base knew about Core…
<companion_cube>
it's probably a trimed down version of Core
<Leonidas>
actually that's something that I would enjoy
<Leonidas>
because the dependencies and build times of core… a 80/20 subset of Core would be something that could be potentially very useful
<flux>
Base?
<Algebr`>
mrvn: how do you link against asan in oasis?
<Algebr`>
plain -lasan in CCOpt isn't working
<Algebr`>
flux: looks like they made yet another stdlib, like a trimmed down core_kernel
<flux>
who..
<benmachine>
i.e. a trimmed down trimmed down core
tane has joined #ocaml
<flux>
I find no mention of Base in the mailing list, in opam search, or /lastlog :)
<Algebr`>
I thought -fsanitize=address would be enough for clang
<flux>
ah, opam update
<Algebr`>
flux: gotta get on twitter
larhat has quit [Quit: Leaving.]
<Algebr`>
grr, I keep getting: Symbol not found: ___asan_option_detect_stack_use_after_return, even though clang is getting the correct -fsantize flag
<flux>
boo, the base package deosn't come with .mli files
<flux>
now where am I supposed to see its documentation.
<Leonidas>
the JSC documentation is already… rather light
<Leonidas>
also difficult to find because google loves their old releases
<ggole>
Jane St really love their stdlib replacements, don't they - isn't this the third?
<ggole>
(If you count core_kernel or whatever that is.)
<Leonidas>
ggole: second.
<Leonidas>
okay, then third
<Leonidas>
but _kernel is probably just "whatever we could get to work on windows"
<flux>
so what's the relationship of core_kernel and base? will the former depend on the latter?
<flux>
or will core_kernel be deprecated
<Leonidas>
I guess there will be some announcement at some point
<flux>
at least the library seems to advocate exceptions-exlicitly-in-function-name-approach
<flux>
but I'm not sure if I like this: module Or_unequal_lengths : sig type 'a t = | Ok of 'a | Unequal_lengths [@@deriving sexp_of] end
<flux>
instead of polymorphic variants, for example
<Algebr`>
probably for speed
<Leonidas>
if it's something I can include in my libraries without having massive dependencies, that'd be cool
<flux>
maybe there aren't many of such modules, but it seems it's not possible to write safe code working with all those values..
<flux>
I think the 'happy case' should be possible to make fast even with polymorphic variables?
shinnya has quit [Ping timeout: 272 seconds]
<flux>
or how slow would the comparison to `Ok be
<Algebr`>
a hash?
<flux>
hashing what?
<flux>
isn't the `Ok hashed at compile time?
bruce_r has quit [Ping timeout: 248 seconds]
Algebr` has quit [Ping timeout: 244 seconds]
<ggole>
For small variants like that you can make it a bit cheaper with some tricks
<ggole>
eg, the nullary constructor will always be tagged, so if the low bit is set you have `Unequal_lengths, otherwise `Ok
<ggole>
The main argument for avoiding polymorphic variants is that you get some awful error messages, and sometimes mistaken code will type check where a regular variant would not.
jwatzman|work has quit [Quit: jwatzman|work]
APNG has quit [Ping timeout: 244 seconds]
APNG has joined #ocaml
ontologiae has quit [Ping timeout: 265 seconds]
agarwal1975 has quit [Ping timeout: 265 seconds]
beaumonta has quit [Remote host closed the connection]
DefinitelyNotAFK is now known as traceroute
traceroute is now known as traceroutelol
<flux>
ggole, but having separate type - and module! - for each different failure scenario must have its downsides as well..
<ggole>
Yeah, you don't get to reuse as much code
<ggole>
I quite like having domain names instead of just Some and None
<ggole>
But you do lose in some ways
<flux>
I'm happy with Ok of 'a | Failure of 'b, at the golden path can be handled in a uniform manner
<flux>
'b might then be a polymorphic variant, or some other sum type
<flux>
it is the basis of the new standard library replacement companion_cube is working on
<flux>
everything builds up from that
<companion_cube>
well yeah, it's actually `Zonked of 'a | NotZonked of 'b | FileNotFound of (exn array,unit) Hashtbl.t`
<flux>
hmm, so you're not using gadts there? how disappointing.
<companion_cube>
who needs GADTs when there is exn ?
<flux>
I suppose you can put gadts inside the exn
<companion_cube>
yeah
<Algebr`>
I missed a little bit of convo, small recap?
<ggole>
I was a bit surprised when I found out that GADTs are per constructor, not per data type, and that exn allowed them
sdothum has quit [Quit: ZNC - 1.6.0 - http://znc.in]
sdothum has joined #ocaml
<flux>
oh
al-damiri has quit [Quit: Connection closed for inactivity]
<flux>
I guess that's useful.
<Algebr`>
has anyone successfully compiled C code with -fsantize=address??
<companion_cube>
hmm, haven't tried
<Algebr`>
tried all kinds of contortions
<Algebr`>
really wanted it
<Algebr`>
companion_cube: the block thing worked!
<Algebr`>
re indention
<companion_cube>
hmm?
<Algebr`>
re long CCOpts
<companion_cube>
ah! nice
<companion_cube>
(I happened to take a look at oasis' parser ^^)
<Algebr`>
its always ocamlmklib that craps out
<Algebr`>
clang just wants: -fsanitize=address
rgrinberg has quit [Quit: WeeChat 1.5]
rgrinberg has joined #ocaml
<Algebr`>
hmm, better to raise an exception or give back an empty list?
<flux>
it really depends.
agarwal1975 has quit [Quit: agarwal1975]
<flux>
is it better to return 0 on addition overflow or throw an exception?
<Algebr`>
exception
<Algebr`>
or give back an option
<Algebr`>
meh, giving back empty list then
<flux>
what does the function do?
<ggole>
Both? Having foo as well as foo_exn isn't unreasonable.
<flux>
for example it's completely reasonable for List.map return an empty list for an empty input :)
<Algebr`>
giving OCaml back a string list of method names for a objective-c object
<Algebr`>
but since giving a string, that class name might not exist
tane_ has joined #ocaml
<Algebr`>
I plan on using this interactively a lot, so doing a match on option is annoying
tane is now known as Guest41743
tane_ is now known as tane
Guest41743 has quit [Killed (leguin.freenode.net (Nickname regained by services))]
<Algebr`>
but empty list is like implicitly saying such a class didn't exist, but an exception is like free self documentation
<flux>
I imagine most of the code could do with an empty list.. it's like List.find_all/filter in that manner.
<Algebr`>
yea, that's what I'm thinking
<flux>
so I think the option is at least out
<flux>
maybe just return an empty list and don't worry about it :)
<Algebr`>
ya, less code for me too ha
agarwal1975 has joined #ocaml
NaCl has left #ocaml [#ocaml]
agarwal1975 has quit [Client Quit]
rgrinberg has quit [Ping timeout: 272 seconds]
tristero has quit [Quit: tristero]
ryanartecona has quit [Quit: ryanartecona]
<flux>
so you're doing some tool to work with Objective C?
<Algebr`>
ya
<Algebr`>
I should have done it sooner
<Algebr`>
I'll be done with it tonight
<copy`>
Is `type 'a foo = Empty | Node of { child: 'a foo; … }` more efficient than `type 'a foo = { child: 'a foo option; … }`?
<Algebr`>
I guess it depends how often you get the Empty
<Algebr`>
cause empty won't be a block
<Algebr`>
but the record will always be a block methinks
<copy`>
None also isn't a block, so in that regard it's the same, isn't it?
<copy`>
I'm wondering if there's an extra level of indirection due to the option
<flux>
I don't think there is, because you're using inline records?
<Algebr`>
damnit, CAMLreturn isn't playing nicely with ternary operator
<flux>
algebr`, how is that possible?
<ggole>
The first variant is more efficient
<ggole>
At least, for now
<flux>
how could it change?
<ggole>
Single-field records could be represented as their contents
<copy`>
ggole: Cool, good to know
<ggole>
(If the field isn't mutable, etc)
<Algebr`>
ah
<Algebr`>
class == nil ? CAMLreturn(Val_emptylist) : CAMLreturn(make_list([class properties]));
<Algebr`>
<flux>
well that doesn't surprise me.
<ggole>
Yeah, return isn't an expression
<flux>
return itself isn't compatible with ternary operator
<flux>
this isn't ml we're talking about ;-)
<Algebr`>
my brain is fried
<flux>
ggole, well in some very distant future where we don't care about backwards compatibility?-)
<ggole>
I don't think it need be distant - there was discussion about it, at least
<ggole>
And the same thing applies for single-argument single constructor variants, eg, type any = Foo : x -> any
<flux>
algebr`, here's a weird trick dennis ritchie hates: if (class==nil) CAMLreturn(Val_emptylist); else CAMLreturn(make_list([class properties]));
<flux>
:)
<ggole>
There may indeed be some compatibility problems with C code though
<flux>
ggole, I suppose I wouldn't mind it, but before that happens, I hope that the C interface gets very significant enhancements as in to discourage writing in direct way
<flux>
but I guess that's mad talk
<ggole>
Yeah, you want something a bit more opaque so that crazy compiler nerds can go beserk and mess up your representation in mind bending ways without breaking anything
<ggole>
Python and Ruby have this problem in spades
<ggole>
It's gotten to the point where the JIT compiler people are interpreting C so they can have visibility into all the C cruft to try to optimise it away
tristero has joined #ocaml
<Algebr`>
flux: heh
rgrinberg has joined #ocaml
<Algebr`>
I wish the C interface was more expressive
<flux>
an expressive C++ interface would at least be feasible
<flux>
but I guess everyone hates c++.. :)
<Algebr`>
not me!
<flux>
also: rust interface would be cool
<flux>
not that I've written a token of rust, but anyway.
shinnya has joined #ocaml
<Algebr`>
the C interface does feel quite a bit dated, like the ocaml side is getting a lot of love and attention lately
<Algebr`>
I was thinking that multicore and runtime attention would have revamped it
<flux>
it would be the best excuse
<flux>
I wonder how things are faring in the multicore land. there's been some github issues, but doesn't seem to be progressing super fast now. but, looks can be deceiving. I hope :)
<Bluddy[m]>
flux: C++ has gotten much better
<Algebr`>
so much better
<flux>
C++ would be practical for making ocaml interface with C libraries as well
agarwal1975 has joined #ocaml
<Algebr`>
yay, finished
slash^ has quit [Read error: Connection reset by peer]
CuriousErnestBro has quit [Ping timeout: 248 seconds]
octachron has joined #ocaml
<Algebr`>
okay amazing, I just wanted to add a _tags file for a not_hygienic and it literally broke everything
octachron has quit [Read error: Connection reset by peer]
CuriousErnestBro has joined #ocaml
fraggle_ has quit [Ping timeout: 265 seconds]
octachron has joined #ocaml
sh0t has quit [Ping timeout: 265 seconds]
ggole has quit []
<Algebr`>
companion_cube: can _oasis file limit what platforms the project can build on, or is that just for opam?
<companion_cube>
you can have conditionals
manizzle has quit [Ping timeout: 240 seconds]
<Algebr`>
yea I know about those, but I mean like not build at all
rgrinberg has quit [Ping timeout: 244 seconds]
<companion_cube>
Build$: something something?
sh0t has joined #ocaml
<Algebr`>
eh, next release
_andre has quit [Quit: leaving]
LiamGoodacre has joined #ocaml
orbifx has joined #ocaml
letaris has joined #ocaml
<orbifx>
sup #ocaml?
<reynir>
hey orbifx o/
<orbifx>
heyo reynir
<orbifx>
Think I saw your nick somewhere recently but could be my memory glitching ^^
<orbifx>
have you got a blog?
<reynir>
I do, but it's mostly empty and boring heh
<reynir>
Maybe it was in #ocaml?
CuriousErnestBro has quit [Ping timeout: 240 seconds]
<orbifx>
maybe, or the mailing list
<flux>
how do I prevent ocamlbuild from finding dependencies?
<flux>
I'm trying to make it use a .cma file, but it also finds the .cmo files via -I, so it ends up using both
<flux>
and this is troublesome for native builds
<flux>
(well but with .cmx)
<orbifx>
maybe the order of the flags flux ?
<flux>
order of what flags?
<reynir>
ow,they changed the github layout
<orbifx>
flux: your inclusion flags like -I ...
<orbifx>
reynir: where?
<orbifx>
flux: I'm guessing, dunno for sure, pressuming it's like gcc and other tools using paths
<reynir>
orbifx: well, I noticed on profile pages
<orbifx>
ow yeah
<flux>
orbifx, well I think I would need to use it for compiling but not for dependency resolving
<flux>
but I'm not sure if that's even possible
<flux>
because it doesn't seem like I'm telling it to use it for dependency resolving, it just does.
<flux>
too bad I'm knee-deep in the sunken cost fallacy, or I would try out solvuu-build :P
<orbifx>
reynir: I want to get a hat or something with the "Keep caml and curry on "
<reynir>
heh
<orbifx>
flux: isn't that what ocamlbuild was made for, and if you need something more custom you need to go with makefiles etc?
<flux>
I think ocamlbuild should be able to build a library in one directory and use it in another..
<flux>
there's this "ocaml_lib" command but I really wonder what it does. I guess I need to look at ocamlbuild sources :(
agarwal1975 has quit [Quit: agarwal1975]
<octachron>
flux, I would think that most of ocamlbuid dependencies resolving is delegated to ocamldep
<flux>
yes..
agarwal1975 has joined #ocaml
<flux>
..but can it be stopped?
<flux>
hmm, this "non_dependency" is maybe what I'm looking for
<flux>
nah
<flux>
ah, ocaml_lib did it, and even worked like it was documented. I had used it earlier but it hadn't seemed useful at all.
octachron has quit [Quit: Leaving]
<orbifx>
any opium users here?
<orbifx>
the package, not the substance :P
<flux>
good that you clarified
<companion_cube>
I thought one was required to use the other
<companion_cube>
now you tell me I took it for nothing?!
<companion_cube>
I will never touch web code every again.
<flux>
well you certainly don't need to take opium to do web development. but it probably helps.
<orbifx>
hehe
<orbifx>
so anyone?
<companion_cube>
I used it a tiny bit
CuriousErnestBro has joined #ocaml
<orbifx>
companion_cube: do you know if params are meant to checked with exceptions or is the more elegant way?
rgrinberg has joined #ocaml
<flux>
hmph, ocamlfind's ocamkmklib-support is limited :-o
LiamGoodacre has quit [Quit: Leaving]
sh0t has quit [Ping timeout: 248 seconds]
sh0t has joined #ocaml
agarwal1975 has quit [Quit: agarwal1975]
<orbifx>
rgrinberg: the man of the hour
<orbifx>
does opium handle POST params?
FreeBirdLjj has quit [Remote host closed the connection]
MercurialAlchemi has quit [Ping timeout: 250 seconds]
orbifx1 has joined #ocaml
tane has quit [Quit: Leaving]
<rgrinberg>
orbifx: urlencoded_pairs_of_body should be useful for that. it doesn't support uploads yet, that's b/c there's no support from upstream (cohttp)