<wmeyer`>
gildor_: does setup.ml does not check for the ocamlfind if the dependencies are satisfied? I would think that at the very last step after configure it has better chances to get that dependencies than on the _oasis level where user didn't even create configure script - not mentioning he didn't request any particular configuration
<thelema_>
yes, isn't his jenkins server down?
<gildor_>
I use it in a more complex way, i.e. building an environment with godi and launching the build inside it
<wmeyer`>
gildor_: the plan would be ocaml setup.ml -configure and then ocaml setup.ml -printdeps, then odb will check what is available and then download the packages and redo the same
<gildor_>
thelema_: I think ygrek's jenkins is down, yes
<gildor_>
wmeyer`: if you are after -configure, the flags should have been set and no more conditional values
<thelema_>
gildor_: won't -configure fail if deps aren't met?
<wmeyer`>
gildor_: yes, so it does mean we have all of the dependencies
<wmeyer`>
thelema_: good point - yes
<gildor_>
thelema_: indeed, good point
<wmeyer`>
thelema_: if we get nice printinting of the error message it would sovle the problem :-)
<wmeyer`>
thelema_: hack: try to configure as much as possible until it stops complaining
<gildor_>
wmeyer`: in this case, I would go for making the BaseConfigure run in "dry-run" so that it just collect dependencies and pretty print it
<gildor_>
BaseConfigure/InternalConfigure
<wmeyer`>
gildor_: Cool! the problem would be solved then? is with the options requested by the user (means in setup.ml and using .data?)
<wmeyer`>
gildor_: I can help with that
<gildor_>
thelema_: most of the release related to oasis in GODI last week was linked to be able to build oasis-db
<wmeyer`>
gildor_: I think you should focus on the oasis-db I can handle that dry-run, it's enough that we know what to do
<gildor_>
wmeyer`: ok
<gildor_>
thelema_: I plan to release when I will have Debian/GODI packages and odb.ml building oasis
<thelema_>
gildor_: odb.ml should be building the last beta of oasis just fine
<gildor_>
thelema_: a source release is nice, a release that is easy to install using your favorite package manager is better
<gildor_>
thelema_: I have no doubt about the ability of odb.ml to build oasis
<thelema_>
ok, just listing it as a requirement for release... :)
<gildor_>
thelema_: I am not happy with the current status oasis-db, it needs to be improved
<thelema_>
gildor_: agreed.
<gildor_>
too much nice feature standing in my dev version and not released, this is not sane
<thelema_>
IMNSHO, the biggest improvements are some more management things (delete packages) for admins
<thelema_>
getting rid of teh scary "ALPHA!!! go away!!!" warnings
<gildor_>
thelema_: that won't be in the next release of oasis-db, but this is high on my list
<thelema_>
and better explanation of the upload page.
<thelema_>
on the upload page itself
<gildor_>
thelema_: I think I will drop the ALPHA for a real release
<gildor_>
oasis-db is working, it is not some random code that crash every now and then
<gildor_>
it is not alpha since a long time
<thelema_>
yup.
<thelema_>
aside from more general server problems, it's been completely stable.
<gildor_>
thelema_: I think the general server problems are now solved
* gildor_
gtg, it is late here
hcarty has quit [Ping timeout: 260 seconds]
hcarty has joined #ocaml
smerz has quit [Remote host closed the connection]
pango has quit [Ping timeout: 252 seconds]
pango has joined #ocaml
Kynes` has quit [Ping timeout: 244 seconds]
Kynes` has joined #ocaml
romildo has quit [Quit: Leaving]
ftrvxmtrx has quit [Quit: Leaving]
digcon9 has joined #ocaml
digcon9 has quit [Read error: Connection reset by peer]
digcon9 has joined #ocaml
ftrvxmtrx has joined #ocaml
digcon9 has quit [Ping timeout: 240 seconds]
digcon9 has joined #ocaml
digcon9 has quit [Read error: Connection reset by peer]
digcon9 has joined #ocaml
Submarine has joined #ocaml
Submarine has quit [Changing host]
Submarine has joined #ocaml
Davidbrcz has joined #ocaml
Davidbrcz has quit [Ping timeout: 265 seconds]
ulfdoz has quit [Ping timeout: 246 seconds]
ulfdoz has joined #ocaml
yezariaely1 has joined #ocaml
yezariaely1 has quit [Client Quit]
yezariaely1 has joined #ocaml
yezariaely1 has quit [Client Quit]
digcon9 has quit [Read error: Connection reset by peer]
ulfdoz has quit [Ping timeout: 256 seconds]
ulfdoz has joined #ocaml
digcon9 has joined #ocaml
yezariaely is now known as jakobro
jakobro is now known as yezariaely
pango is now known as pangoafk
yezariaely has left #ocaml []
yezariaely has joined #ocaml
NaCl has quit [Ping timeout: 246 seconds]
NaCl has joined #ocaml
NaCl has quit [Changing host]
NaCl has joined #ocaml
testcocoon has quit [Ping timeout: 246 seconds]
Submarine has quit [Ping timeout: 246 seconds]
ski has quit [Ping timeout: 246 seconds]
Fnar has quit [Ping timeout: 246 seconds]
mfp has quit [Ping timeout: 246 seconds]
mfp has joined #ocaml
ski has joined #ocaml
testcocoon has joined #ocaml
Submarine has joined #ocaml
Submarine has quit [Changing host]
Submarine has joined #ocaml
Fnar has joined #ocaml
Fnar has quit [Changing host]
Fnar has joined #ocaml
ulfdoz has quit [Read error: Operation timed out]
testcocoon has quit [Client Quit]
digcon9 has quit [Read error: Connection reset by peer]
digcon9 has joined #ocaml
digcon9 has quit [Client Quit]
digcon9 has joined #ocaml
testcocoon has joined #ocaml
digcon9 has quit [Read error: Connection reset by peer]
digcon9 has joined #ocaml
digcon9 has quit [Read error: Connection reset by peer]
emmanuelux has quit [Ping timeout: 264 seconds]
Submarine has quit [Ping timeout: 246 seconds]
djcoin has joined #ocaml
ocp has joined #ocaml
Sablier has joined #ocaml
digcon9 has joined #ocaml
fpz has quit [Ping timeout: 246 seconds]
cyphase has quit [Ping timeout: 248 seconds]
fpz has joined #ocaml
hcarty has quit [Ping timeout: 260 seconds]
hcarty has joined #ocaml
cyphase has joined #ocaml
digcon9 has quit [Ping timeout: 245 seconds]
hcarty has quit [Ping timeout: 260 seconds]
hcarty has joined #ocaml
digcon9 has joined #ocaml
digcon9 has quit [Client Quit]
digcon9 has joined #ocaml
silver has joined #ocaml
digcon9 has quit [Read error: Connection reset by peer]
<adrien>
ocaml has "vmthreads" which are green ones iirc
<Kakadu>
adrien: +1
avsm has quit [Quit: Leaving.]
digcon9 has quit [Read error: Connection reset by peer]
digcon9 has joined #ocaml
Hussaind has joined #ocaml
cago has quit [Ping timeout: 244 seconds]
Hussaind has left #ocaml []
Yoric has joined #ocaml
<Kakadu>
What do you think: does OCaml LLVM backend with embedded SMP will be cool?
<adrien>
the issue with SMP is entirely that the GC is not thread-safe
<adrien>
if you want one, see oc4mc (ocaml 4/for multicore)
<adrien>
also, ocamlnet has facilities to make multicore easier to use
<adrien>
and
<adrien>
"functory" iirc
<fasta>
Would you think it is a terrible, terrible idea for a language to have implicit calls?
<flux>
implicit calls?
<fasta>
I.e. something like f x = length -- let's assume that we know that x is a list.
<fasta>
So, instead of returning a function here, it returns length x
<fasta>
Now, if there is no list in scope, it returns the function lenght.
<fasta>
length*
<flux>
yes, I think it's a terrible idea :)
<flux>
what would be a compelling use case?
<fasta>
I.e. because of type-inference there is a lot of redundant information.
<fasta>
I think it is fairly compelling myself, because you can just say f x = drop 5 (take 5 ++ reverse) for example.
<fasta>
Instead of f x = drop 5 (take 5 x ++ reverse x).
<fasta>
It's perfectly obvious that you are talking about x there.
<fasta>
In the case of multiple lists you would need to disambiguate.
<fasta>
But one of the hall marks of functional programming is to have lots of simple functions.
<fasta>
But perhaps that's just to keep the GC writers busy?
<fasta>
^^
<eikke>
$ pointfree "\x -> drop 5 (take 5 x ++ reverse x)"
<eikke>
drop 5 . ap ((++) . take 5) reverse
<flux>
I really don't think drop 5 (take 5 x ++ reverse x) is a lot more to read or write here.
cdidd has quit [Remote host closed the connection]
Submarine_ has joined #ocaml
<Ptival>
fasta: how is it obvious that you're talking about x, and not [] ?
<fasta>
Ptival: it would only work for identifiers which are not at the top-level.
<Kakadu>
btw, Does oc4mc has gome to production?
<adrien>
it's been tested and has proven to be quite stable
<adrien>
but the devs are still looking for more testing
<flux>
fasta, so this: let home axis = send ("G28 " ^ String.concat " " (List.map (fun x -> name_of_axis x ^ "0") axis)) unit_response would become this: let home = send ("G28 " ^ String.concat " " (List.map (name_of_axis ^ "0"))) unit_response
<flux>
I'm not certain if I would be able to follow the last one
<Kakadu>
adrien: So Harrop's argument vs. OCaml is almost fixed? :)
<flux>
adrien, nice to hear that. I have just a project that could use it :). although it would probably just make do with ocamlnet
<flux>
but I understand it's a bit unsafe
<adrien>
flux: oh!
<adrien>
what a great idea you just had!
<flux>
I did?! great!
<adrien>
it's great to know that you're going to try the different solutions available and write about their ease-of-use and performance!
<adrien>
:-)
<fasta>
In general, that's quite bad. I mean people act as if tools with vastly different amount of effort and quality of people that went into it are equal.
<fasta>
(That's why the benchmark games are good.)
<adrien>
flux: I hope I didn't scare you ;-)
<fasta>
The longer the benchmark, the better, though.
<flux>
I shall consider that when I get too bored with the performance
<fasta>
Especially graph algorithms would be a good benchmark.
<fasta>
ghci is for example even too slow for even the simplest script.
<flux>
my algorithm is one of those embarrassingly parallelizing issues
<flux>
well, almost. it can be more difficult if I do parallelizing with lower granularity
<fasta>
I have a program which computes the absolute path to some file and it takes 0.4 seconds or so via ghci.
<fasta>
Via ghc it's like 0,001 or something like that.
<fasta>
But it does show that interpretation via ghci is not viable.
<flux>
well, it does compliation etc
<fasta>
It should figure out: "am I going to have to do a lot of work?".
<fasta>
If yes, then compile, if no, direct interpretation.
<flux>
the developers have figured out: it doesn't matter :)
<flux>
I don't think GHC has code to do interpretation.
<fasta>
flux: it compiles to bytecode.
<eikke>
ghc has both
<fasta>
flux: and they interpret that. \
<fasta>
eikke: no, it doesn't have a true interpreter.
<eikke>
and you can mix'n'match bytecode and native
<fasta>
eikke: it has a byte code compiler which is then interpreted.
<eikke>
that's what i meant
<fasta>
eikke: anyway, the end-result is that it is terribly slow to start and interpret a file of Haskell code.
<fasta>
eikke: just compare it to sh scripts.
<flux>
I think it boils down to that GHC is very slow to compile
<flux>
ocamlnat also compiles everything, and AFAIK it's very fast interactively
<fasta>
I wouldn't mind writing my scripts in Haskell (and I have written some), but in the end I just have to compile it.
<flux>
if you want fast haskell interaction, use hugs..
<fasta>
It is hard to know whether it would be better or worse overall to use symbol tables, because this aspect of the design is so fundamental that it is almost impossible to change. Still, avoiding symbol tables is a natural choice in the purely functional setting, so it seems likely that this approach is a good choice for Haskell.
<fasta>
Uhm, ok... questionable design right there.
BiDOrD_ has joined #ocaml
<fasta>
It's in the 'it's Haskell, so let's make it slow'-excuses list.
<fasta>
Or in the 'data-structures are hard', let's go shopping list.
<fasta>
If you give a first year student an assignment how to design this properly at least the asymptotics work out.
_andre has joined #ocaml
BiDOrD has quit [Ping timeout: 244 seconds]
digcon9 has quit [Ping timeout: 265 seconds]
osa1 has joined #ocaml
thomasga1 has joined #ocaml
thomasga has quit [Read error: Connection reset by peer]
eni has joined #ocaml
digcon9 has joined #ocaml
ocp has joined #ocaml
cago has joined #ocaml
digcon9 has quit [Ping timeout: 256 seconds]
digcon9 has joined #ocaml
digcon9 has quit [Read error: Connection reset by peer]
digcon9 has joined #ocaml
Davidbrcz has joined #ocaml
osa1 has quit [Quit: Konversation terminated!]
eni has quit [Quit: Leaving]
digcon9 has quit [Read error: Connection reset by peer]
digcon9 has joined #ocaml
digcon9 has quit [Ping timeout: 252 seconds]
digcon9 has joined #ocaml
Davidbrcz has quit [Remote host closed the connection]
Davidbrcz has joined #ocaml
bjorkintosh has joined #ocaml
ftrvxmtrx has quit [Quit: Leaving]
Kakadu has quit [Quit: Page closed]
fraggle_ has joined #ocaml
oriba has joined #ocaml
digcon9 has quit [Ping timeout: 248 seconds]
digcon9 has joined #ocaml
gmcabrita has joined #ocaml
iago has joined #ocaml
Davidbrcz has quit [Ping timeout: 244 seconds]
snearch has joined #ocaml
digcon9 has quit [Ping timeout: 252 seconds]
gnuvince has quit [Ping timeout: 250 seconds]
<flux>
fine example of why not to put -Werror to release packages can be found from ocaml mailing list :P
<flux>
(well, it's only the problem in one package, bin_prot)
<adrien>
for C/gcc
<adrien>
but there is also at least one occurence of -warn-error A too
gnuvince has joined #ocaml
<Drakken>
Suppose I have a functor that defines a type in terms of an abstract type from the functor's argument.
<Drakken>
Is the implementation of the inner type sealed off forever? I wanted to write a function that takes the functor's type but has access to the innter type's internals.
<Drakken>
iNNer
<Drakken>
(I want the function to take a _value_ of the type defined in the functor)
Kakadu has joined #ocaml
Kakadu has quit [Client Quit]
Kakadu has joined #ocaml
<Drakken>
Oh well, I guess that doesn't make sense.
Davidbrcz has joined #ocaml
snearch has quit [Quit: Verlassend]
testcocoon has quit [Quit: Coyote finally caught me]
testcocoon has joined #ocaml
Snark has joined #ocaml
gnuvince has quit [Ping timeout: 260 seconds]
emmanuelux has joined #ocaml
ftrvxmtrx has joined #ocaml
dwmw2_go` has joined #ocaml
bitbckt has quit [Ping timeout: 245 seconds]
dwmw2_gone has quit [Ping timeout: 248 seconds]
bitbckt has joined #ocaml
<thelema_>
Drakken: yes, if you give a functor an abstract type, it can't create values of that type. maybe give the functor somr construction functions too?
hcarty has quit [Ping timeout: 260 seconds]
hcarty has joined #ocaml
mal`` has quit [Read error: Operation timed out]
mal`` has joined #ocaml
<Drakken>
thelema_ I want the inner type to be totally open-ended, including constructors.
<Drakken>
I assume the real answer is polymorphic variants.
<Drakken>
(instead of a regular variant type)
Submarine_ has quit [Ping timeout: 245 seconds]
Davidbrcz has quit [Remote host closed the connection]
Davidbrcz has joined #ocaml
Asmadeus has quit [Ping timeout: 260 seconds]
Asmadeus has joined #ocaml
ssbr_ has quit [Ping timeout: 260 seconds]
ssbr_ has joined #ocaml
ssbr_ is now known as Guest82433
pollux has quit [Remote host closed the connection]
pollux has joined #ocaml
gnuvince has joined #ocaml
benozol has joined #ocaml
cago has quit [Quit: Leaving.]
Sablier has quit [Read error: Connection reset by peer]
ocp has quit [Ping timeout: 244 seconds]
oriba has quit [Quit: oriba]
<jonafan>
hmmmmmmm
<jonafan>
one of my xml's turns out to be bigger than i thought
smondet has joined #ocaml
digcon9 has joined #ocaml
avsm has joined #ocaml
cdidd has joined #ocaml
habnabit has joined #ocaml
Sablier has joined #ocaml
avsm has quit [Quit: Leaving.]
digcon9 has quit [Quit: Lost terminal]
_habnabit has quit [Ping timeout: 245 seconds]
Davidbrcz has quit [Remote host closed the connection]
Davidbrcz has joined #ocaml
djcoin has quit [Quit: WeeChat 0.3.2]
<hcarty>
thelema_: You're welcome. I'm glad I got the lineage correct for bench :-)
thomasga1 has quit [Ping timeout: 244 seconds]
ftrvxmtrx has quit [Ping timeout: 252 seconds]
eikke has quit [Ping timeout: 246 seconds]
iago has quit [Ping timeout: 265 seconds]
ftrvxmtrx has joined #ocaml
kolera has joined #ocaml
hnrgrgr_ has quit [Remote host closed the connection]
err404 has joined #ocaml
iago has joined #ocaml
Yoric has quit [Ping timeout: 248 seconds]
thomasga has joined #ocaml
Davidbrcz has quit [Remote host closed the connection]
Davidbrcz has joined #ocaml
Submarine_ has joined #ocaml
snearch has joined #ocaml
iago has quit [Read error: Operation timed out]
<wmeyer`>
hi
Kakadu has quit [Quit: Konversation terminated!]
pangoafk is now known as pango
Tobu has joined #ocaml
Davidbrcz has quit [Remote host closed the connection]
Davidbrcz has joined #ocaml
ulfdoz has joined #ocaml
snearch has quit [Quit: Verlassend]
kmicinski has joined #ocaml
<ski>
Drakken : did you want to write this function inside the functor, or outside ?
Snark has quit [Quit: Quitte]
wtetzner has joined #ocaml
<Drakken>
ski It doesn't really have to be a function. the outer variant type is a syntax tree and the inner type is the terminals. I just need to extend a camlp4 grammar entry to return values of the inner type to be used as leaf nodes in the ast.
<Drakken>
I don't think regular variants will work.
<ski>
i assume you have something like `module MyFunctor : functor (Arg : ARG) -> sig ..(Arg.t).. end' ?
<Drakken>
Anyway, it would have to be outside the functor, because it needs a rule for each variant/terminal.
<adrien>
morning wmeyer` ;-)
<Drakken>
I don't think the ast type is going to be used outside the functor. The interface will be the entry-point parser.
<ski>
(or maybe i'm misunderstanding the problem ..)
ulfdoz has quit [Ping timeout: 248 seconds]
ulfdoz has joined #ocaml
<Drakken>
Maybe it doesn't need the functor. I'm still a little fuzzy about how polymorphic variants work :(
<adrien>
magic!
benozol has quit [Ping timeout: 244 seconds]
Davidbrcz has quit [Remote host closed the connection]
Davidbrcz has joined #ocaml
ulfdoz has quit [Ping timeout: 244 seconds]
Yoric has joined #ocaml
ulfdoz has joined #ocaml
fschwidom has joined #ocaml
iago has joined #ocaml
<jonafan>
i wish i knew databases better
fraggle_ has quit [Read error: Connection reset by peer]
mcstar has joined #ocaml
<mcstar>
isnt it weird, that a multi-parameter type constructor takes a tuple as its argument?
<mcstar>
or is this for disabling syntactically partial type constructor application?
fschwidom has quit [Remote host closed the connection]
kmicinski has quit [Ping timeout: 246 seconds]
Yoric1 has joined #ocaml
kmicinski has joined #ocaml
Yoric has quit [Ping timeout: 264 seconds]
<ski>
i'm not sure it's specifically meant to disable partial application of type synonyms, but i suppose that's a consequence
<mcstar>
ski: oh, you hang out here too?
<ski>
though, such partial application wouldn't be very useful without allowing higher-order types (and yes i know one can simulate those to some degree with functors)
<mrvn>
If it weren't a tuple would a b c t be (a,b,c)t or (a,b) c or ((a,b), c) t?
<mcstar>
ski: i think i lost you, does this mean you dont have higher order types in ocaml?
<ski>
i know MetaML added higher-order types, and it reinterprets `(t0,t1) f' as meaning `t0 (t1 f)' (or maybe the other way around ?) -- i'm not sure whether MetaOCaml does something similar, but i supspect it may well do
<ski>
mcstar : yes
<mrvn>
mcstar: we don't have 'a 'b types.
brendan has joined #ocaml
<ski>
# type 'f t = C of in t'f;;
<ski>
Error: Syntax error
<mrvn>
"of" "in"?
<mcstar>
int
<ski>
er, sorry, s/in/int/
<ski>
# type (type f) t = C of int f;;
<ski>
Error: Syntax error
<ski>
both are syntax errors, in any case
<mcstar>
ski: can you give me an example of this from haskell?
<mcstar>
mrvn: in haskell there is no ambiguity in interpreting type constructor arguments, and type constructors are functions, on which you can pattern match
<jonafan>
i just spent a couple of hours figuring out pgocaml and postgres administration for no reason
<ski>
abstracting out the reference type out of a data structure type
<ski>
IndirectComposite
<ski>
# type ('a,'ref) �list = ('a,'ref) cell 'ref and ('a,'ref) cell = Nil | Cons 'a * ('a,'ref) list;;
<ski>
Error: Syntax error
habnabit is now known as _habnabit
<ski>
we can do (int,ref) list , (int,identity) list , (int,hashref) list &c.
<ski>
you can do this sort of thing (but clunkier) with functors -- and then in some cases you'd need to generate modules (with specialized code) at run-time
Davidbrcz has quit [Remote host closed the connection]
Davidbrcz has joined #ocaml
<ski>
of course, being able to generate specialized code with a functor is a very cool thing, but for the special case where we don't need to actually perform different operations at run-time, it'd be nice to be able to use the lighter alternative (higher-order types, and operations polymorphic over "type constructor variables")
<mcstar>
uh, sry
<mcstar>
interesting
<ski>
what you can do, instead of `list' above, is to make a functor, which takes a module containing a type `ref' as input, and produces as output a module containing the operations you wanted to use for `list'
<mcstar>
im not there yet, i read that modules are first class citizens in ocaml?
<ski>
(assuming all these operations use the same `ref' consistently -- you couldn't write a function which changes the `ref' type in this way -- possibly you can do it with some more complicated functor trick, i'm not sure)
<_habnabit>
jonafan, there's primitives, even if you can't define your own
<mcstar>
_habnabit: im wasnt criticising ocaml
<mcstar>
-m
<jonafan>
oh yeah
<_habnabit>
mcstar, saying "it's not much simpler than C++" is tantamount to an insult
<mcstar>
well, then sry, dont take it as such
<mcstar>
_habnabit: btw, i said 'doesnt seem to be'
<adrien>
the devil is in the details
<_habnabit>
yes, that's what I said
<adrien>
mcstar: the difference is that after a few hours, you will know ocaml pretty well
<adrien>
you'll still learn new things but you'll already know a good chunk after only a few hours
<mcstar>
type-fu needs time to sink in :)
<mcstar>
adrien: i tried haskell first, it was very strange at first, but quickly got to like it, but it has the downside(?) that i keep comparing ocaml to it
<Qrntz>
it is not actually haskell's downside
<Qrntz>
haskell has enough of its own
<mcstar>
no, i meant that i met haskell first, and ocaml second
ftrvxmtrx has quit [Read error: Connection reset by peer]
dsheets has quit [Excess Flood]
benozol has quit [Remote host closed the connection]
dsheets has joined #ocaml
<jonafan>
lazy evaluation is not my favorite
<Qrntz>
mcstar, I think disciple could become a haskell that's closer to ocaml, but overall they're quite different
<mcstar>
i cant afford time to learn about research languages, id better stick to one/ones with larger user base
<mcstar>
haskell is sort of mind expanding, and quite good, but since its hard for a novice to argue about its space time complexity, i chose to learn about ocaml too
ftrvxmtrx has joined #ocaml
<mcstar>
(and its great, since you can bring a good portion of ocaml knowledge to f# if needed)
ggherdov has joined #ocaml
osa1 has joined #ocaml
Phlogistique has joined #ocaml
<fasta>
OCaml has a larger userbase than Haskell?
<fasta>
Since when?
eni has joined #ocaml
<mrvn>
What is Haskell? :)
<mcstar>
fasta: how did you figure i said that?
kmicinski has joined #ocaml
Davidbrcz has quit [Remote host closed the connection]