adrien changed the topic of #ocaml to: Discussions about the OCaml programming language | http://www.ocaml.org | Upcoming OCaml MOOC: https://huit.re/ocamlmooc | OCaml 4.03.0 release notes: http://ocaml.org/releases/4.03.html | Try OCaml in your browser: http://try.ocamlpro.com | Public channel logs at http://irclog.whitequark.org/ocaml
Heasummn has quit [Remote host closed the connection]
Heasummn has joined #ocaml
cryyya has quit [Ping timeout: 240 seconds]
ygrek has quit [Ping timeout: 265 seconds]
cryyya has joined #ocaml
ydl has quit [Ping timeout: 248 seconds]
ydl has joined #ocaml
<ydl> k
ydl has left #ocaml [#ocaml]
ydl has joined #ocaml
dougt_ has quit [Ping timeout: 240 seconds]
tmtwd has joined #ocaml
tmtwd has quit [Ping timeout: 272 seconds]
ee_ks1 has quit [Ping timeout: 248 seconds]
pseudo-sue has joined #ocaml
mfp has quit [Ping timeout: 276 seconds]
ygrek has joined #ocaml
rgrinberg has quit [Ping timeout: 244 seconds]
shinnya has quit [Ping timeout: 248 seconds]
Heasummn has quit [Quit: Leaving]
rgrinberg has joined #ocaml
kamog has quit [Remote host closed the connection]
rgrinberg has quit [Quit: WeeChat 1.5]
rgrinberg has joined #ocaml
bruce_r has joined #ocaml
kamog has joined #ocaml
pseudo-sue has quit [Ping timeout: 248 seconds]
ydl has left #ocaml ["ERC (IRC client for Emacs 24.5.1)"]
sdothum has quit [Quit: ZNC - 1.6.0 - http://znc.in]
tmtwd has joined #ocaml
sdothum has joined #ocaml
pierpa has quit [Ping timeout: 248 seconds]
phase_ has joined #ocaml
sdothum has quit [Quit: ZNC - 1.6.0 - http://znc.in]
MercurialAlchemi has joined #ocaml
nore has quit [Quit: WeeChat 1.4]
MercurialAlchemi has quit [Ping timeout: 250 seconds]
MercurialAlchemi has joined #ocaml
tmtwd has quit [Remote host closed the connection]
MercurialAlchemi has quit [Ping timeout: 265 seconds]
phase_ has quit [Remote host closed the connection]
rwmjones has quit [Ping timeout: 265 seconds]
rwmjones has joined #ocaml
average has joined #ocaml
<average> How do you call "the time it too for an HTTP request to complete"? roundtrip time? response time?
<adrien> average: response time
<average> ok thanks
average has left #ocaml [#ocaml]
rgrinberg has quit [Ping timeout: 240 seconds]
govg has quit [Ping timeout: 255 seconds]
bruce_r has quit [Ping timeout: 255 seconds]
ggole has joined #ocaml
cxii has joined #ocaml
tmtwd has joined #ocaml
ggole_ has joined #ocaml
MercurialAlchemi has joined #ocaml
ggole has quit [Ping timeout: 272 seconds]
tmtwd has quit [Ping timeout: 260 seconds]
ggole__ has joined #ocaml
ggole_ has quit [Ping timeout: 272 seconds]
FreeBirdLjj has joined #ocaml
copy` has quit [Quit: Connection closed for inactivity]
ggole__ has quit [Ping timeout: 276 seconds]
Simn has joined #ocaml
Orion3k has quit [Quit: Leaving]
SIGGIL is now known as SIGILL
ygrek has quit [Remote host closed the connection]
ygrek has joined #ocaml
nicholas_ has quit [Remote host closed the connection]
nicholasf has joined #ocaml
nore has joined #ocaml
ygrek has quit [Ping timeout: 260 seconds]
AltGr has joined #ocaml
nicholasf has quit []
rwmjones is now known as rwmjones_hols
ggole has joined #ocaml
zpe has joined #ocaml
SIGILL has quit [Changing host]
SIGILL has joined #ocaml
wolfcore has quit [Ping timeout: 244 seconds]
wolfcore has joined #ocaml
mfp has joined #ocaml
snhmib has joined #ocaml
Orion3k has joined #ocaml
larhat has joined #ocaml
jwatzman|work has joined #ocaml
kamog has quit [Quit: ERC (IRC client for Emacs 24.5.1)]
larhat has quit [Read error: Connection reset by peer]
larhat1 has joined #ocaml
snhmib has quit [Quit: WeeChat 1.3]
jwatzman|work has quit [Quit: jwatzman|work]
jwatzman|work has joined #ocaml
<Algebr`> hannes: can the tls code do most of what openssl can do, the cmdline tool?
<Algebr`> I have a der cert and want to convert to a pem
<hannes> Algebr`: I think you can do via utop, but there is no command-line tool... look into https://mirleft.github.io/ocaml-x509/X509.Encoding.html
<Algebr`> thanks!
tane has joined #ocaml
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 ?
MercurialAlchemi has joined #ocaml
Sorella has joined #ocaml
Algebr` has joined #ocaml
rgrinberg has quit [Quit: WeeChat 1.5]
agarwal1975 has joined #ocaml
rgrinberg has joined #ocaml
<companion_cube> menhir options ?
<companion_cube> XOCamlbuildExtraArgs: "-menhir 'menhir --dump --explain' -j 0"
<companion_cube> stuff like this
<companion_cube> ?
<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> yes!
<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 ;)
<companion_cube> you mean like solvuu ?
<flux> yes.. by providing a new build system.. :)
<Algebr`> companion_cube: why, did caml params change or something? I've written quite a bit of c ffi stuff already
<flux> but solvuu doesn't do anything for ctypes, does it?-o
<companion_cube> Algebr`: ah fine, if you already know
<companion_cube> flux: no idea
ryanartecona has quit [Quit: ryanartecona]
<flux> but I must say I'm really tempted to try it out
<flux> though I suppose it's not that bad..
<flux> and not sure if solvuu even helps ;)
<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.
<Algebr`> free labor: send a PR!
rgrinberg has quit [Quit: WeeChat 1.5]
rgrinberg has joined #ocaml
<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
bruce_r has joined #ocaml
<ggole> It's also common to have "named" bools
agarwal1975 has joined #ocaml
<ggole> type t = Zonked | NotZonked
<companion_cube> Zonked | NotZonked | FileNotFound
<ggole> I wish I didn't know what that was.
Algebr` has joined #ocaml
<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)
<Algebr`> cohttp still can't do upload?
<rgrinberg> not quite. it can, but you need to use another opam package in conjunctoin https://github.com/cryptosense/multipart-form-data
<orbifx1> rgrinberg: any examples?
Heasummn has joined #ocaml
pyon has quit [Quit: Fix config.]
pyon has joined #ocaml
pyon has quit [Client Quit]
pyon has joined #ocaml
manizzle has joined #ocaml
AltGr has left #ocaml [#ocaml]
<orbifx1> not me
Simn has quit [Read error: Connection reset by peer]