<Algebr>
I'm interested in using ctypes and just a small confusion, how do you bind to functions not part of posix? say your custom library. It seems you have to compile it separatenly and then pass a -l argument to ocamlc?
<Algebr>
oh to -cclib i guess
swgillespie has joined #ocaml
hilquias has joined #ocaml
<Drup>
yes
<Algebr>
can utop do something like -cclib?
<Drup>
no, you can still do bindings in ctypes using libffi
<Drup>
(it's the default way of doing things anyway)
<Algebr>
I looked at doing it that way and it looks way more tedious. But in any case I just tried the simpliest attempt at getting a separate c libary. I'm getting this exception Fatal error: exception Dl.DL_error("dlsym(RTLD_DEFAULT, adder): symbol not found"). I defined a functionc called adder in simple.c. all compiled fine together.
swgillespie has quit [Quit: My MacBook Pro has gone to sleep. ZZZzzz…]
keen___________ has joined #ocaml
keen__________ has quit [Ping timeout: 264 seconds]
shinnya has quit [Ping timeout: 256 seconds]
victoroak has joined #ocaml
<victoroak>
topic
victoroak has quit [Client Quit]
psy_ has quit [Ping timeout: 264 seconds]
psy_ has joined #ocaml
<blech_>
Let's say I'm working with a tree data structure composed of a recursive variant type. I'm going to have to transform it to another format and back. I am going to be using the same structure in my construction step (through composition) and in my decomposition step (pattern matching)
<blech_>
though for each of these I'm going to have to duplicate the structure
<blech_>
is there something I can do to reuse that definition?
AndChat|618624 has joined #ocaml
TSMI has quit [Ping timeout: 246 seconds]
<jcloud>
what do you mean? why do you have to redefine a new variant type each time?
<jcloud>
to define*
Algebr has quit [Ping timeout: 272 seconds]
<struktured>
curious..why doesn't partial function application type check for this? let f ~x ~y z = if z then x else int_of_string y in f 3 "2" . I thought it would work because it's unambiguous here, despite not using the labels.
<blech_>
jcloud, I don't mean that I'm defining a new variant every time
<blech_>
jcloud, let's say I'm trying to pull some data out of a JSON object. If I've got a function that's extracting that content I'm going to do something like match json with Object [ ("name": String realname ) ] -> (*act on realname*). Later on if I'm trying to go from my intermediary format back to the JSON representation I'm going to do Object [ ("name", String realname) ] again as my final expression to return it
<blech_>
for larger structures this duplication gets to be troublesome
<struktured>
computationally? I don't undestand your problem, but maybe I don't know the scope.
<blech_>
not computationally, I just don't like having the same structure defined twice
<jcloud>
Why do you have to define it twice? I am not sure what is the problem.
<struktured>
yeah.. you can wrap that in a function..but if thatsthe whole pattern what do large structures have to do w/it?
<tobiasBora>
Does anyone knows how to remove the warning "Warning: ocp-indent input contains indentation by tabs, partial indent will be unreliable." in ocp-indent ?
<struktured>
tobiasBora: do you inssit on keeping tabs?
<struktured>
tobiasBora: *insist
rock_neurotiko has quit [Ping timeout: 272 seconds]
<blech_>
jcloud, let's say we're dealing with JSON as the recursive variant type. If I've got a function json -> mytype I'm going to pull the content out from the json structure and wrap it in mytype. If I have a function mytype -> json I'm going to compose the appropriate JSON structure. If I then change the layout of that JSON object that I'm generating I have to update it in both places and my naive idealistic thought is I'd like to be
<blech_>
able to define this mapping once and be able to apply it in either direction.
<tobiasBora>
struktured: No I don't really want to keep tabs
AndChat|618624 has quit [Ping timeout: 258 seconds]
leafac has joined #ocaml
<jcloud>
blech_: this sounds almost like the expression problem... So you are saying that you don't like having to update the code that handles the structure whenever you change the structure?
TSMI has joined #ocaml
<jcloud>
if you are going to change the layout, it seems to me as if you will have to change the code; unless there is some way for the code to automatically find out how to do the conversion both ways, or to compute the inverse of an ocaml function :P
<tobiasBora>
struktured: Actually I'm using emacs, but I think that (setq indent-tabs-mode nil) should do the job. Thank you !
<blech_>
jcloud, I've got no problem changing the structure and changing the code to match
<blech_>
I'd just like to only have to change it in one place rather than two
BitPuffin|osx has quit [Ping timeout: 256 seconds]
<jcloud>
okay, so to clarify, you would prefer to update only, say, the json -> something code, rather than both that and the something -> json code?
<jcloud>
if it would really save you time, you might program functions that operated more generally on some sort of specification structure + either the json or the other type, I.e. when you changed the layout you would change the specification rather than the code itself
<struktured>
blech_: ppx deriving json out of the question?
<struktured>
blech_: I felel like you can't really do what you're saying without a declarative approach.
<struktured>
*feel
<tobiasBora>
Hum
<tobiasBora>
Lwt seems to have removed the module Lwt_util, but what should I use to iter on lists now ?
<Drup>
Lwt_list
<tobiasBora>
Thank you (and I'm stupid the doc writes "use Lwt_list"...)
Denommus has joined #ocaml
ygrek has joined #ocaml
leafac has quit [Ping timeout: 255 seconds]
nullcat_ has joined #ocaml
oscar_toro has quit [Ping timeout: 276 seconds]
oscar_toro has joined #ocaml
Guest63092 has joined #ocaml
mcclurmc has joined #ocaml
mcclurmc_ has quit [Ping timeout: 265 seconds]
idegen has quit [Quit: Leaving.]
c74d has quit [Remote host closed the connection]
c74d has joined #ocaml
sdothum has quit [Quit: ZNC - 1.6.0 - http://znc.in]
Guest63092 has quit [Ping timeout: 258 seconds]
wraithm has quit [Quit: leaving]
chambart has quit [Ping timeout: 265 seconds]
<struktured>
is there a builtin function like the following ? "let always x = fun _ -> x" (I know it's trivial but seems common enough to have anyhow)
mcclurmc has quit [Remote host closed the connection]
AndChat|618624 has joined #ocaml
TSMI has quit [Ping timeout: 276 seconds]
<blech_>
struktured, that's not a bad idea. Personally I try to avoid preprocessors when possible so I would like to leave that as a last resort but thanks, that probably would work
hilquias has quit [Ping timeout: 246 seconds]
<IbnFirnas>
does anyone know if nested recursive modules are possible to define?
<l1x>
what is the right way to configure the log level with core?
<l1x>
it is barely documented
inf-gropeoid has quit [Ping timeout: 256 seconds]
matason has joined #ocaml
wwilly has joined #ocaml
rgrinberg has quit [Ping timeout: 258 seconds]
c74d is now known as Guest53397
c74d3 has joined #ocaml
Guest53397 has quit [Ping timeout: 256 seconds]
matason has quit [Ping timeout: 258 seconds]
avsm has joined #ocaml
clog has joined #ocaml
MercurialAlchemi has quit [Remote host closed the connection]
MercurialAlchemi has joined #ocaml
avsm has quit [Quit: Leaving.]
kushal has joined #ocaml
mcclurmc has joined #ocaml
c74d3 is now known as c74d
mengu has joined #ocaml
mengu has joined #ocaml
mcclurmc has quit [Ping timeout: 264 seconds]
Simn has joined #ocaml
orbitz_ has quit [Quit: Reconnecting]
orbitz has joined #ocaml
psy_ has quit [Ping timeout: 265 seconds]
Cyanure has joined #ocaml
pii4 has joined #ocaml
matason has joined #ocaml
matason has quit []
bobry has joined #ocaml
rgrinberg has joined #ocaml
<flux>
re mainlinglist: "- New configure option "-no-naked-pointers" to improve performance by avoiding page table tests during block darkening and the marking phase of the major GC. In this mode, all out-of-heap pointers must point at things that look like OCaml values: in particular they must have a valid header. The colour of said headers should be black. (Mark Shinwell, reviews by Damien Doligez and Xavier Leroy)"
<flux>
aren't naked pointers used oftentimes by C bindings?
<flux>
I suppose that's bad then?
rgrinberg has quit [Ping timeout: 272 seconds]
<ggole>
Presumably that is why it is an option
<ggole>
Seems like it could get you into trouble though
<ggole>
You'd have to know whether any of your dependencies were using such C bindings
<flux>
I wonder how much does it give performance benefits
<flux>
maybe if you have particularly GC-heavy app?
<flux>
I suppose C bindings could be fixed to use custom allocations and putting the pointer there?
<flux>
in fact the GC should also have a debug mode for finding if an application uses such pointers..
<ggole>
Changing the way libraries allocate is not necessarily a simple thing to do
<flux>
it's been some time since I've done C bindings.. but isn't it a matter of just wrapping the pointer with another block?
<ggole>
C libraries might also return pointers that do not point to the beginning of a C allocation, eg, to something inside an array
<ggole>
Wrapping the pointer itself might work...
Gama11 has joined #ocaml
siddharthv is now known as siddharthv_away
leowzukw has joined #ocaml
Bhavya has quit [Ping timeout: 264 seconds]
<companion_cube>
struktured: what do you mean? CCFun.const has existed for a long time ;)
Bhavya has joined #ocaml
Bhavya has quit [Read error: Connection reset by peer]
<companion_cube>
maybe it still works with opaque blocks?
<companion_cube>
flux, ggole: if opaque blocks can still contain naked pointers, it should be fine; just wrap C stuff in a ocaml record/variant
octachron has joined #ocaml
<ggole>
In other words, rewrite the binding.
<companion_cube>
well that might be already the case
rgrinberg has joined #ocaml
<ggole>
So if there's no problem, there's no problem. But if there's a problem there's a problem. :)
<ggole>
The question in my mind is how easy it is to determine whether you can safely use this feature.
<companion_cube>
right
rgrinberg has quit [Ping timeout: 245 seconds]
ollehar has joined #ocaml
<flux>
if it crashes.. ;)
<companion_cube>
call Gc.compact() a lot
<companion_cube>
:D
Cyanure has quit [Remote host closed the connection]
<ggole>
(It doesn't actually ever return a bool because it can't be reached, but still, definitely off.)
<ggole>
The "real fix" is to use the let rec eval : type a . a expr -> a = ... form
<ggole>
Which requires that the type variable be polymorphic as I intended.
<ggole>
(And that makes the case reachable.)
<bernardofpc>
ouch
<bernardofpc>
so the first form induces the GADT type to be a single one, and not generalized, right ?
<ggole>
Seems so, yeah
<ggole>
Which is not so bad in itself, but the missing exhaustiveness is quite confusing
<flux>
regarding inline records: will they work with GADTs as well?
<ggole>
They will, I was asking Drup about this
<ggole>
I incorrectly believed they didn't, but I was just confused about the syntax
freling has quit [Quit: Leaving.]
<octachron>
flux: if you are willing to argue the case of .!%<{..}>%! with the maintainers, I will gladly write the corresponding patch :p
<flux>
octachron, well funky operators would make OCaml look more appealing to newcomers?
<bernardofpc>
not sure
<bernardofpc>
already newcomers have the ; vs ;; clash
<bernardofpc>
(which is simple but takes time to incorporate)
<ggole>
bernardofpc: actually, it's a bit stranger than that... if you reduce the eval to just the Lt case, it still gets int expr -> int O_o
<ggole>
I think this is because the return type is unified with the inner calls to eval.
<bernardofpc>
ggole: weird
<ggole>
Yeah, not the most intuitive thing.
<bernardofpc>
with the first (type a) syntax ?
<ggole>
Yeah. With the second it's fine.
<octachron>
flux: the appeal to ascii-artists newcomers that don't want to feel constrained in their artistic freedom?
<bernardofpc>
ggole: and it gets an "unexaustive pattern"
<companion_cube>
flux: they have camlp4 if they want
<bernardofpc>
is there not a simple syntax (sugar?) for defining a gadt function with a \forall and many arguments ?
<companion_cube>
let rec f: type a b c. ..... = fun .... -> .....
<octachron>
ggole: I think it is a problem of higher order rank polymorphism. Without (forall a.) annotation eval can only be first rank polymorphic so its type is determined at call time
<bernardofpc>
something like """ let rec eval (level : int) \forall a (e : a level expr) : a = match e with ...
<ggole>
octachron: sure, but that's not really the problem: I'm happy with the idea that I have to provide certain annotations for polymorphism.
<ggole>
The issue is that the exhaustiveness check isn't really exhaustive.
Hannibal_Smith has quit [Quit: Leaving]
badkins has joined #ocaml
<octachron>
Well, the match pattern is still exhaustive in your example, even if redundant.
Hannibal_Smith has joined #ocaml
<ggole>
All right, the redundancy check
<companion_cube>
I assume the type checker prefers to be over-conservative when it checks exhaustiveness
leafac has quit [Ping timeout: 245 seconds]
<struktured>
companion_cube: I just discovered CCFun yesterday, when looking for const
<companion_cube>
\o/
<companion_cube>
it exists because I dislike putting even more stuff in pervasives
Gama11 has quit [Quit: No Ping reply in 180 seconds.]
Gama11 has joined #ocaml
rgrinberg has joined #ocaml
<struktured>
companion_cube: it's a good name for the module
<companion_cube>
gah, Uuidm doesn't provide pretty-printers?
<adrien_znc>
nicoo: companion_cube is saying that /dev/urandom is costly :P
<nicoo>
Well, the costly part is actually doing the syscall, so a small read is (proportionnaly) costlier than a large one. But you should only need to init your RNG once at application startup, so why should C³ care ?
<companion_cube>
adrien_znc: I thought so
<nicoo>
companion_cube: SO TELL ME, WHY DO YOU CARE? ;_;
<adrien_znc>
:)
<companion_cube>
never mind
<adrien_znc>
I could have typed all that long sentence but all I had to do was to poke nicoo \o/
<adrien_znc>
:D
<companion_cube>
14998229/s <--- ok, uuidm is not that costly
rgrinberg has joined #ocaml
<companion_cube>
(number of unique random IDs created per second)
<nicoo>
companion_cube: If you want moar performance, be my guest and call getentropy() (on platforms where it is supported)
<ggole>
Unroll those loops!
<companion_cube>
oh right, that would make a good benchmark for flambda
<companion_cube>
and it made me peek at UUID, which are cool
<MercurialAlchemi>
uuids are cool, but queries with on tables with uuids as primary key you need to type manually, less so :)
<companion_cube>
copy/paste ?
<companion_cube>
:D
<MercurialAlchemi>
companion_cube: yeah, ugh
<flux>
best to handle primary keys as strings in your app
<flux>
then you can switch to uuids when you have done enough ad-hoc queries during development ;-)
* MercurialAlchemi
throws a ball of string at flux
<MercurialAlchemi>
string-typist!
<flux>
might just as well be a string, you're not going to perform arithmetics on them.
<flux>
there's one reasonable solution in the comments: use both
<flux>
though I guess it's a bit redundant
<MercurialAlchemi>
from the comments "well, they were using MongoDB, so not really a database"
<MercurialAlchemi>
I wouldn't want to use two keys
<MercurialAlchemi>
too confusing
<companion_cube>
anyway, I find uuid cools, not necessarily only for databases
<MercurialAlchemi>
I'd be interested to have some numbers when it comes to performance
<flux>
uuids will sound a relatively good idea when you have multiple databases you want to join at some point :)
<companion_cube>
well you see, 1.5M uuid generated in 1s
<MercurialAlchemi>
question is, if you want to use this in a distributed setup, how long before you get a collision?
<companion_cube>
flux: well, small probability of collision
<companion_cube>
much better than autoincrement
<flux>
I understand it's negligible
<MercurialAlchemi>
guy in the comments was saying "at work we use both: a sequential primary key (oracle sequence): because it is still faster than UUID when you have multiple joins AND an alternate uuid key that we expose to the outside world"
<flux>
with 2^46 RFC UUIDs there's a probability of 4e-10 of a collision
<companion_cube>
2^46 is already a huge number of primay keys, isn't it?
<flux>
yep. but I suppose you still want to prepare for pk conflicts just for sake of completeness. regenerating the key when the insert gives you a key constraint should fix it.
<flux>
hopefully with some mechanism easy to deploy to all inserts
QuanticPotato has quit [Ping timeout: 264 seconds]
<flux>
in fact.. maybe postgresql could learn to do this by itself in future ;-)
<flux>
at least if the db is the one that creates the uuid, that might not be applicaple in all cases
<companion_cube>
flux: according to the blogpost you can still enforce uniqueness constraint
<companion_cube>
but then, yes, renaming would be tough
<companion_cube>
(in case of a merge with collision)
<flux>
sure, of course you enforce uniqueness constraint
<flux>
well, not super tough, given ON UPDATE CASCADE?
A1977494 has joined #ocaml
QuanticPotato has joined #ocaml
<flux>
..but if you don't have indices to make that happen it could be very slow..
<companion_cube>
of course, you need to index by primary key
<flux>
but there are other tables that refer to the table with a foreign key, so you need an index on that fk as well
<flux>
whereas normally you might not need it
<flux>
in fact, while developing such a system, you should use a random integer from 1 to 10000. to shake out the conflict resolving bugs ;)
MercurialAlchemi has quit [Ping timeout: 272 seconds]
MercurialAlchemi has joined #ocaml
milosn has joined #ocaml
Khady has quit [Remote host closed the connection]
Khady has joined #ocaml
zpe has joined #ocaml
QuanticPotato has quit [Ping timeout: 240 seconds]
QuanticPotato has joined #ocaml
xificurC has joined #ocaml
willy_ has joined #ocaml
wwilly has quit [Ping timeout: 264 seconds]
zpe has quit [Remote host closed the connection]
rand000 has quit [Ping timeout: 265 seconds]
slash^ has joined #ocaml
lordkryss has quit [Quit: Connection closed for inactivity]
slash^2 has quit [Ping timeout: 252 seconds]
mengu has quit []
shinnya has joined #ocaml
freling has joined #ocaml
gabemc has joined #ocaml
rand000 has joined #ocaml
rand000 has quit [Client Quit]
octachron has quit [Quit: Leaving]
kushal has joined #ocaml
Haudegen has quit [Ping timeout: 240 seconds]
tane has joined #ocaml
kushal has quit [Ping timeout: 256 seconds]
rgrinberg has quit [Ping timeout: 256 seconds]
milosn has quit [Read error: Connection reset by peer]
milosn has joined #ocaml
rgrinberg has joined #ocaml
darkf has quit [Quit: Leaving]
QuanticPotato has quit [Ping timeout: 272 seconds]
QuanticPotato has joined #ocaml
Haudegen has joined #ocaml
Unhammer has quit [Quit: WeeChat 1.1.1]
Denommus has quit [Ping timeout: 264 seconds]
QuanticPotato has quit [Ping timeout: 250 seconds]
<Drup>
nullcat: by pure curiosity, why are you interested in pretty-printing javascript ? :)
<companion_cube>
to debug calls to eval(), probably
<companion_cube>
:>
Hannibal_Smith has joined #ocaml
<apache2>
is there an equivalent of 'type .. = ... and .. = ..' for let-bindings of fucntions?
<apache2>
(or, mutually recursive functions)
<apache2>
oh, 'let rec ... = ... and ... = ...' worked. I had an extra 'rec' in front of the second.
shinnya has quit [Ping timeout: 272 seconds]
rand000 has joined #ocaml
ygrek has joined #ocaml
freling has quit [Quit: Leaving.]
BitPuffin|osx has quit [Ping timeout: 246 seconds]
<adrien>
I'm looking for someone who's using the cygwin port of ocaml
<adrien>
not the windows one running from cygwin
<adrien>
I'd just like to know if it actually works
<adrien>
so ask your friends too
leowzukw has quit [Quit: leaving]
rgrinberg has quit [Ping timeout: 258 seconds]
<blech_>
Question for the group: I've got a validation pipeline set up that I'd like to be extensible by users of my API. I've got a couple of thoughts so far and I'm not sure what would be the recommended approach. 1 - functorize the validation module to allow people to inject other validation systems in. 2 - allow an optional parameter for the validation function that is a function (M a -> M a) where M is a validation status monad of
<blech_>
some sort. The user's rule would get chained onto the end of the current chain and finally be broken down to return the result of the validation.
hilquias has joined #ocaml
hilquias has quit [Changing host]
hilquias has joined #ocaml
<ggole>
The quick'n'dirty way would be to have a list ref of user validation functions
<ggole>
I assume you want to collect all the validation failures rather than just bailing at the first sign of trouble?
hilquias has left #ocaml ["ERC Version 5.3 (IRC client for Emacs)"]
contempt has quit [Remote host closed the connection]
Anarchos has joined #ocaml
asQuirreL has quit [Ping timeout: 265 seconds]
shinnya has joined #ocaml
<blech_>
ggole, correct
<ggole>
Seems easier to just collect a list and have the user's function not care about chaining or anything like that (if possible)
<ggole>
Particularly since you're likely to want to do things like catch any exception raised by the validation functions
lobo has joined #ocaml
Denommus has joined #ocaml
inf-gropeoid has joined #ocaml
badkins has quit []
<blech_>
in the continued spirit of noob questions
<blech_>
is it worth it to define a submodule for utility functions?
<blech_>
as in I don't want to take a dependency to core or batteries but I need some string utilities so I create a StringExt module
<Drup>
just use stringext and stop rewriting them
<blech_>
fair enough
<ggole>
Dependencies aren't so bad these days
badkins has joined #ocaml
cmtptr has quit [Quit: leaving]
tumdum has joined #ocaml
rgrinberg has joined #ocaml
cmtptr has joined #ocaml
tumdum has quit [Client Quit]
tumdum has joined #ocaml
rgrinberg has quit [Ping timeout: 244 seconds]
<nullcat>
Drup: because I need to demo in class... just want to display something nice
rgrinberg has joined #ocaml
matason has joined #ocaml
gabemc has quit [Ping timeout: 255 seconds]
thomasga has quit [Quit: Leaving.]
ggole has quit [Ping timeout: 272 seconds]
thomasga has joined #ocaml
A19774941 has joined #ocaml
sepp2k has joined #ocaml
A1977494 has quit [Ping timeout: 264 seconds]
asQuirreL has joined #ocaml
tmtwd has quit [Remote host closed the connection]
matason has quit []
slash^ has quit [Ping timeout: 252 seconds]
slash^ has joined #ocaml
tmtwd has joined #ocaml
jbrown has quit [Remote host closed the connection]
A1977494 has joined #ocaml
A19774941 has quit [Ping timeout: 244 seconds]
Algebr has joined #ocaml
nullcat has quit [Ping timeout: 246 seconds]
<Algebr>
I'm trying out the ctypes library but where can't seem to find a way to make an enum. One of the tests included in ctypes source is test-enum and in that directory there is an enum function but I can't seem to find it defined...and it doesn't exist at the Ctypes.enum expected place..
nojb has joined #ocaml
TheLemonMan has joined #ocaml
badkins has quit [Read error: Connection reset by peer]
<Algebr>
I see that its explained, but enums aren't available right now in the latest version of ctypes available via opam...so I should just use ints at the moment?
<Algebr>
anyone off the top of their head know how to declare a variadic argument in ctypes?
<rgrinberg>
Drup: is it possible to do it without graphics_js though? just pure canvas
<rgrinberg>
ideally i just want a blank page with a canvas
<rgrinberg>
(showing this to a friend who doesn't much ocaml but knows canvas really well)
<tane>
is there not some kind of FFI for JS, which can be used to easily wrap all the necessary functions/types?
<Drup>
well, sure, graphics_js is implemented in term of usual canvas stuff ..
rock_neurotiko has joined #ocaml
rock_neurotiko has left #ocaml [#ocaml]
mort___ has joined #ocaml
<nullcat_>
is UK on holiday now?..
<rgrinberg>
nullcat_: US is
<companion_cube>
why so?
<companion_cube>
is it a religious thing?
<struktured>
memorial day, veteran related
<nullcat_>
U.S is having Memorial Day
<companion_cube>
ok
<struktured>
more ocaml for me, is how I see it
<nullcat_>
well, no one answers my issues in no-crypto, Mindy in ocamllab went to vacation. avsm went to greece... that's why I am wondering if UK is having holiday..
BitPuffin|osx has joined #ocaml
<nullcat_>
never mind..
<companion_cube>
similarly, opam-repo PRs are not merged
<struktured>
the horror
<companion_cube>
nah, that's fine ^^
<rgrinberg>
nullcat_: time to read sources...
<struktured>
its a slow time of year, in general.
<rgrinberg>
nullcat_: in europe you get a lot of vacations
<rgrinberg>
not like in NA
<nullcat_>
...that's good
<rgrinberg>
but here we get way more food to eat
A1977494 has left #ocaml [#ocaml]
<nullcat_>
although u.s is having holiday, in my lab 3/6 PhDs come to work today...
<nullcat_>
(* I am not PhD *)
<struktured>
well even in US most people work to osme degree all the time
<rgrinberg>
:'(
<struktured>
workaholicking is quite I call it
<struktured>
*quite/what
<struktured>
is it List.fold_right, in stdlib, that is unsafe for large # of iterations?
asQuirreL has quit [Quit: My MacBook Pro has gone to sleep. ZZZzzz…]
<dora-molly>
rgrinberg: I am testing the code in your issue, I don't even have completion on js objects in merlin
Anarchos has quit [Quit: O vont da kousk emaon !!]
<rgrinberg>
dora-molly: hmm i do
asQuirreL has joined #ocaml
<dora-molly>
weird
<rgrinberg>
dora-molly: actually, never mind it's a little finnicky. Doesn't pop up for me anymore
<dora-molly>
ok, I prefer
<rgrinberg>
dora-molly: definitely seems broken
sepp2k has quit [Quit: Leaving.]
<l1x>
wow everything works, after I moved to module X = Y.Z.Q
<l1x>
so open just includes everything from that module?
<l1x>
while module just imports the submodule? or what is the terminology for Re2.Std.Re2 for example
<Drup>
it doesn't include really, but yes, everything is in the scope
<Drup>
(because there is also include, which does something different)
<Drup>
and "module" ... create a module ? :)
<tobiasBora>
Hello !
mcclurmc has quit [Remote host closed the connection]
rand000 has quit [Quit: leaving]
<rgrinberg>
tobiasBora: Hi!
<nullcat__>
hi!
<dora-molly>
ho
<tobiasBora>
I am getting crazy with Makefile, is it possible to use ocamlbuild to define Makefile-like commands ?
<Drup>
oasis does that for you
<tobiasBora>
Drup: My project is too complex for oasis...
<tobiasBora>
And I'm pretty sure that writing a "from scratch" script in ocaml to compile my program would be more efficient that using Makefile...
<rgrinberg>
tobiasBora: no such thing. but perhaps your _oasis file will grow larger than your project
<tobiasBora>
rgrinberg: I want to use it to build a website with ocsigen and _oasis isn't usable for that stuff...
<tobiasBora>
Well I think I'm going to write my own Make-like ^^
<tobiasBora>
Make-like program*
<rgrinberg>
tobiasBora: why don't you use ocamlbuild?
Simn has quit [Quit: Leaving]
<Leonidas>
can someone explain how to read the deflate RFC? I'm looking at my hexeditor and scratching my head how the deflate blocks are represented
<Leonidas>
my program and me, we both agree that the data is invalid, yet zlib decompresses it %)
<tobiasBora>
rgrinberg: Well ocamlbuild can build some basics parts of my website, but after I want to put together several parts of my website and I don't know if it's possible to do that with ocamlbuild...
<tobiasBora>
Is it possible to run random code with ocamlbuild ?
freling has quit [Quit: Leaving.]
<rgrinberg>
tobiasBora: it's possible to run ocaml code and shell commands with ocamlbuild
<dora-molly>
rgrinberg: issue reporting fixed (ugly fix :D), completion still being tackled