<ggole>
Oh yeah, and you'll still get "unbound constructor" if you just name a module (due to the way the syntax works).
<ggole>
Something like module X = Core.Std might be better
tlockney has quit [Excess Flood]
tlockney has joined #ocaml
<technomancy>
can you curry =?
<technomancy>
oh I see; I was missing the "open"
<ggole>
If you mean partially apply, ((=) 1)
<ggole>
There are no sections though
<ggole>
So that's the first argument, not the rightmost argument
<technomancy>
nice; thanks
levi` is now known as levi
<zRecursive>
how to upgrade 3.12 to 4.0.x in freebsd ?
introom has joined #ocaml
<technomancy>
I've got a list of [x;y] positions and want to build an index of which positions map to what values... what are my options?
<technomancy>
associative list?
<ggole>
That, Hashtbl or Map
<technomancy>
looks like hash tables are mutable; don't want that
<ggole>
Map then
<technomancy>
cool
<technomancy>
a vector of vectors would be fine too if it could be inserted into efficiently, but that's a tal order
<technomancy>
tall
manud has quit [Quit: manud]
zpe has joined #ocaml
zpe has quit [Ping timeout: 240 seconds]
ggole has quit [Ping timeout: 240 seconds]
<levi>
Is there a convenient way to tell opam to just build and install what's in the current directory? Or do I have to set up a local repository?
Nahra has quit [Quit: leaving]
ollehar has joined #ocaml
ulfdoz has joined #ocaml
ygrek has quit [Ping timeout: 246 seconds]
introom has quit [Remote host closed the connection]
ggole has joined #ocaml
<orbitz>
levi: if you've pinned a package to your dir, you mean?
<levi>
I mean, I have a package I've downloaded into a directory and built manually, but I'd like to have it installed with the rest of the opam libraries.
<orbitz>
an opam package?
<levi>
Yes. I have been away from ocaml for a while, so I am not very familiar with these recent tools.
<levi>
I am trying to install it from a local directory instead of directly from its source because it has a minor incompatibility with my system that I had to fix.
zpe has joined #ocaml
<orbitz>
levi: I'd just make an opam repository, add it to your list of repos and you can do opam install
ulfdoz has quit [Ping timeout: 246 seconds]
<levi>
OK. Kind of a pain, but I'll manage. Thanks.
<orbitz>
levi: or just modify your OCAMLPATH to point into the directory you just built and you don't have to d oanything
<orbitz>
or just submit the package to opam so everyone can benefit :)
<levi>
It's not my package, or I would. :)
djcoin has joined #ocaml
<orbitz>
levi: What do you mean? It's alread yin opam but you didn't write it?
<levi>
It's not in the public opam repository, but it's in someone else's repository.
<orbitz>
is the package itself public?
<orbitz>
i mean, what hte package installs
<orbitz>
if it's all open, I don't think there is any social or legal reason you can't repackage it
zpe has quit [Ping timeout: 248 seconds]
<levi>
I'm sure it'll get released when it's ready.
<zRecursive>
Can i use opam to upgrade 3.12 to 4.0.x ?
<levi>
I think you can use it to install 4.0.x.
<zRecursive>
levi: thx, i am studying to use opam now
<orbitz>
zRecursive: It won't upgrade your system, just the one you use iva opam
<orbitz>
via
<zRecursive>
orbitz: do you mean i need to install 4.0.x manually ?
* zRecursive
maybe i can wait for the newest ocaml into freebsd ports
<gasche>
zRecursive: OPAM cannot be built from a versino of OCaml older than 4.00
<gasche>
so either you get a binary distribution of it, or you have to install a 4.00 on your system beforehand
<gasche>
it would have been better for OPAM devs to support 3.12 as well, but well they didn't
<gasche>
levi: note that you can have local OPAM packages, and in the packaging information you can store a patch to be applied against the upstream source
<gasche>
if you want to keep this manually-changed package around long-term, that would be a better option
<orbitz>
zRecursive: I mean that opam does not interact with your system at large, it installed things locally so installing a version of ocaml doesnot change it for your entire system
<zRecursive>
gasche: ok
<zRecursive>
orbitz: yeah
<zRecursive>
opam --version => 1.1.0
<gasche>
in practice most OPAM packages are probably just installing libraries through ocamlfind, so a non-OPAM-packaging that also uses ocamlfind should be compatible
<gasche>
but then you'll have to handle reinstallation yourself when the OPAM repo changes
<zRecursive>
"opam list => Installed packages for system:\n base-bigarray ...", opam indeed works with my ocaml 3.12
<gasche>
zRecursive: "opam switch show" will give you "system"
<gasche>
the opam switch is configured to point to your OCaml "system" install, the one that was there before OPAM
<zRecursive>
yeah
testcocoon has quit [Quit: Coyote finally caught me]
<zRecursive>
opam switch show => system
<gasche>
if you want to install a 4.00, without touching your system, you can install it as a different switch
<gasche>
(each switch is an independent installation of an OCaml version and any librairies packaged for that version in OPAM)
<zRecursive>
gasche: install 4.0.x manually ?
<gasche>
you don't need to
<zRecursive>
oh
<gasche>
I *think* "opam switch 4.00.1" will do the installation by itself
zpe has joined #ocaml
<gasche>
hm
<gasche>
that would probably be "opam switch install 4.00.1", in fact
<zRecursive>
using root
<zRecursive>
?
<zRecursive>
can i install using ordinary user account ?
<zRecursive>
i want to install 4.00.1 into ~/ocaml
<orbitz>
everything an opam can be done as a nonroot user
<orbitz>
opam does not install thigns in ~/ocaml
<zRecursive>
great
<gasche>
read the manual :-'
<orbitz>
by default at least
hkBst has joined #ocaml
<orbitz>
Why do you need it in ~/ocaml?
<zRecursive>
ls ~/ocaml/bin/ => opam opam-mk-repo now
<orbitz>
I'm not sure what you're showing me with that line
<orbitz>
I still don't know what you're trying to tell me
<zRecursive>
orbitz: now i am using 3.12, and i want install 4.0.1 into ~/ocaml
<orbitz>
Why does it need to be in ~/ocaml?
ygrek has joined #ocaml
<zRecursive>
i donot want it disturb 3.12
<gasche>
but ~/.opam/... would be fine as well, right?
<zRecursive>
sure
<gasche>
well
<orbitz>
zRecursive: You can isntall in many places that won' tdistrubte 3.12
<gasche>
at some point zRecursive I think you should go read the OPAM documentation
<zRecursive>
i will
<gasche>
instead of having us re-hash it to you in a badly worded way over an IRC channel
<zRecursive>
heh
<gasche>
the short line is that by default, "opam switch install 4.00.1" will install the new version in ~/.opam
<gasche>
(but you may have explicitly configured it to do otherwise)
zpe has quit [Ping timeout: 240 seconds]
<zRecursive>
switching now, thx
<zRecursive>
awesome, it is VERY fast
* zRecursive
wish our old ocaml projects will work under 4.00.1 ...
cago has joined #ocaml
fmardini has joined #ocaml
introom has joined #ocaml
introom has quit [Ping timeout: 260 seconds]
<adrien_oww>
morning
ben_zen has quit [Quit: leaving]
mcclurmc has joined #ocaml
zpe has joined #ocaml
Xom has quit [Ping timeout: 248 seconds]
zpe has quit [Ping timeout: 240 seconds]
Simn has joined #ocaml
dsheets has joined #ocaml
zpe has joined #ocaml
MarcWeber has quit [Ping timeout: 245 seconds]
testcocoon has joined #ocaml
MarcWeber has joined #ocaml
ttamttam has joined #ocaml
zRecursive has left #ocaml []
zRecursive has joined #ocaml
yezariaely has joined #ocaml
<zRecursive>
After `opam switch install 4.00.1` and `opam config env`, ocaml reports: Cannot find file topfind. Unknown directive `require'. (there is #require "str";; in ~/.ocamlinit)
ttamttam has quit [Quit: ttamttam]
<zRecursive>
seems i need to install topfind ?
thomasga has joined #ocaml
<zRecursive>
but i donot know its package name
<gasche>
zRecursive: opam install ocamlfind
<gasche>
(topfind is part of ocamlfind/findlib, but you're right the name is not easy to guess)
<zRecursive>
gasche: thanks
quelu_ has quit [Ping timeout: 260 seconds]
quelu has joined #ocaml
<zRecursive>
gasche: do i need to put the output of `opam config env` into ~/.bashrc ?
<zRecursive>
it is ok now, thx
zRecursive has left #ocaml []
<yezariaely>
I want to work with the BatResult monad and I am missing the >> operator. Where can I find it? additionally, I'd like to have a mapM (map lifted to monads) is this available somewhere?
Xom has joined #ocaml
<gasche>
yezariaely: map over what?
quelu has quit [Ping timeout: 245 seconds]
<gasche>
BatEnum has a WithMonad functor that produces "sequence" (probably the mapM you're looking for) and "fold_monad"
<yezariaely>
I have a function f : t -> (a',b') BatResult.t and now I have a lst : t list and want to apply map f lst. The result should however be an error, if there is one error.
<gasche>
other Batteries module are not that well-furnished
<yezariaely>
gasche: sounds correct.
<yezariaely>
I will have a look
<yezariaely>
ehm correct is the wrong word. "good" is better.
<gasche>
if you want to contribute WithMonad functors for other datastructures, that could be a good idea
<yezariaely>
is Core better wrt. monads?
<gasche>
(and we could extend the range or supported monadic-lifted operations)
<gasche>
I don't know
<yezariaely>
yeah, maybe but time is a problem as with anyone ;)
<ousado>
yezariaely: are you aware of wmeyers omonad?
<yezariaely>
ousado: yes I am but never tried it. Does it work with Batteries.BatResult?
<gasche>
omonad, in its present shape, is a Bad Idea
sgnb has quit [Read error: Connection reset by peer]
sgnb has joined #ocaml
<gasche>
there is no way to make -ppx writers that do not disturb the existing syntax of the language
<gasche>
so it should be considered a prototype/experiment only, and not actually used
<gasche>
pa_monad are better choices if you want long-term monadic syntax extension
<ousado>
gasche: disturb the syntax of the language?
<yezariaely>
gasche: is the >> operator defined anywhere in Batteries
<gasche>
yezariaely: I don't think so
<yezariaely>
:(
<gasche>
ousado: omonad gives a new meaning to a syntactically valid OCaml expression
<gasche>
whereas pa_monad extends the language to allow previously undefined constructs
<gasche>
yezariaely: patches welcome :]
<yezariaely>
sure ;-) well, let's see I have holidays in two weeks. Maybe I can do something.
sgnb has quit [Remote host closed the connection]
sgnb has joined #ocaml
Anarchos has joined #ocaml
Kakadu has joined #ocaml
ggole has quit [Ping timeout: 256 seconds]
zpe has quit [Ping timeout: 246 seconds]
Xom has quit [Quit: ChatZilla 0.9.90.1 [Firefox 22.0/20130618035212]]
rossberg has joined #ocaml
<whitequark>
gasche: I've been thinking about various RTTI techniques (not necessarily as an application to my SSA thingy), and it turns out that there are three possibilities, and they nicely correspond between OCaml and C-langs
zpe has joined #ocaml
<whitequark>
the first one is to make a class method return a string with a class name, then, in match expression which aims to do narrowing, simply compare this string within a guard clause.
<whitequark>
this is exactly how C++'s dynamic_cast<> typically works
<whitequark>
(no wonder it's slow as hell)
<whitequark>
the advantage is that there is a true open-world model which supports any kind of dynamic linking. the disadvantage is mainly speed.
mort___ has joined #ocaml
<whitequark>
the second one is to declare a sum type with a variant for every possible subclass, and add a method #repr, which returns a value of that type
ggole has joined #ocaml
<whitequark>
this roughly corresponds to what LLVM's homegrown RTTI does--except LLVM's implementation is able to handle deep inheritance trees by exploiting the fact that C++ enums are ordered
<whitequark>
and in OCaml that would, I think, require a distinct sum type for each intermediate class
<whitequark>
at least if you'd want to take advantage of exhaustiveness checking
mcclurmc has quit [Ping timeout: 256 seconds]
<whitequark>
the third way would be to implement a technique similar to dynamic linking: place initialization code besides each class which would build a lookup structure, then again use guards in match clauses to perform queries to that structure
<whitequark>
this one is most complex, but it potentially offers efficiency and an open-world model
<whitequark>
gasche: by the way, how do GADTs simplify the task compared to regular ADTs?
avsm has joined #ocaml
quelu has joined #ocaml
pango has quit [Remote host closed the connection]
mcclurmc has joined #ocaml
mfp has joined #ocaml
osa1 has joined #ocaml
mort___ has quit [Quit: Leaving.]
Snark has joined #ocaml
mort___ has joined #ocaml
<gasche>
whitequark: GADTs allow to transfer equalities between types
<gasche>
if you have a blurb type 'a value that contains everything
<gasche>
and you want to do what you call RTTI on it
<gasche>
with ADTs, you would have a
<gasche>
type 'a rtti_value = Int of int | Float of float | ... | Bar of narrowed_value_in_the_bar_case
<gasche>
and have a function (inspect : 'a value -> 'a rtti_value)
<gasche>
match inspect foo with Bar foo_refined -> ...
<gasche>
so in the branch, foo_refined is *assumed* to be equivalent to foo, and it has the refined type (statically)
<gasche>
with GADTs you could do things a bit differently
<gasche>
type 'a rtti_tag = Int : int rtti_tag | ... | Bar : narrowed_value_in_the_bar_case rtti_tag
<gasche>
when you match on a (a rtti_tag), in the Int case, you learn the type equality (a = int)
<gasche>
so code would look like
<gasche>
match inspect_tag foo with Bar -> ...
<gasche>
and in this branch, locally, `foo` itself has type narrowed_value_in_the_bar_case
q66 has joined #ocaml
<gasche>
whitequark: so I'd say that with GADTs, you can refine typing information without changing the dynamic value you're looking at
<gasche>
(hm, forget the 'a parameter on rtti_value, it's useless)
<gasche>
if you are fine with changing the dynamic value as a first step, it is better to use simpler type-system features of course
<gasche>
GADTs give painful error messages
<whitequark>
interesting
osa1 has quit [Ping timeout: 240 seconds]
osa1 has joined #ocaml
tane has joined #ocaml
Kakadu has quit []
Kakadu has joined #ocaml
Simn has quit [Read error: Connection reset by peer]
dsheets has quit [Ping timeout: 248 seconds]
fmardini has quit [Ping timeout: 256 seconds]
ttamttam has joined #ocaml
amirmc has joined #ocaml
fmardini has joined #ocaml
ttamttam has quit [Client Quit]
dsheets has joined #ocaml
Neros has quit [Ping timeout: 268 seconds]
Neros has joined #ocaml
<kerneis>
gasche: ocamlbuild --helps tells among other things
<kerneis>
-no-stdlib Don't ignore stdlib modules
<kerneis>
is it really "Don't ignore"?
<kerneis>
it seems counter-intuitive
Neros has quit [Ping timeout: 260 seconds]
tane has quit [Quit: Verlassend]
osa1 has quit [Remote host closed the connection]
osa1 has joined #ocaml
_andre has joined #ocaml
ygrek has quit [Ping timeout: 245 seconds]
beckerb has joined #ocaml
amirmc has quit [Quit: Leaving.]
Anarchos has quit [Quit: Vision[0.9.7-H-130604]: i've been blurred!]
amirmc has joined #ocaml
yezariaely has quit [Quit: Leaving.]
skchrko has joined #ocaml
osa1 has quit [Ping timeout: 245 seconds]
osa1 has joined #ocaml
ollehar has joined #ocaml
introom has joined #ocaml
amirmc has quit [Quit: Leaving.]
yezariaely has joined #ocaml
<kerneis>
okay, now another ocamlbuild question
<kerneis>
is there simple way to convince ocamlbuild to include someexternallib.cmo inside mylib.cma, using ocamlfind?
<kerneis>
if I just put Someexternallib inside mylib.mllib, it fails to find it
<kerneis>
(which is arguably a bug, or maybe not)
<adrien_oww>
"include"?
<kerneis>
include cannot point above your root directory
<kerneis>
this is another "feature"
<kerneis>
root = where myocamlbuild.ml is
<kerneis>
yes, I could use symbolic links, but this is really overkill
<kerneis>
sequencing would have to do with the order of execution
<introom>
got it.
<kerneis>
let has the lowest precedence
<introom>
really? ',' should be lower than 'let'
<kerneis>
well, look at the table in my previous link
<kerneis>
given your example, I think I disagree
<kerneis>
you definitely want to be able to write let x = 3 in x, x
<kerneis>
without the extra parentheses
<kerneis>
would lead to horrible bugs otherwise
<kerneis>
imagine:
<kerneis>
let f x = let x = x*2 in x, x
<kerneis>
f 3 would return (6, 3)
cdidd has quit [Ping timeout: 246 seconds]
cdidd has joined #ocaml
<introom>
kerneis: yeah. let's precedence means the clause "let xx in"'s precedence, that makes sense.
<gasche>
kerneis: beware that while including .cma in .cma is allowed, this won't work for .cmxa
<gasche>
(or at least something something in the native case)
<gasche>
I prefer to avoid compilation options that don't work both in byte and native modes
<gasche>
hm
Drup has joined #ocaml
<kerneis>
gasche: cmxa in cmxs works though
<kerneis>
at least in my test-case
<kerneis>
maybe i'm just lucky
<kerneis>
btw, does anybody agree that there is an issue with the help message here: "ocamlbuild --help|grep stdlib" or is it just me being confused?
<gasche>
I have no idea what -no-stdlib does
<gasche>
so
<gasche>
looking at the sources, kerneis
<gasche>
the message is right but confusing
<gasche>
when computing the dependencies of a module through ocamldep, ocamlbuild will filter out what's part of stdlib
cdidd has quit [Remote host closed the connection]
<kerneis>
oh, yes
<gasche>
if you want to build in an environment where no stdlib is available (and you would pass -nostdlib to the OCaml compiler), you would want modules having those names to also appear in the dependencies, hence "don't ignore them"
<kerneis>
so the option name is in fact misleading
<kerneis>
hmm, ok
cdidd has joined #ocaml
<gasche>
I think the name is correct
<gasche>
but the description could have to be improved; not sure how, though
<kerneis>
in fact, it's completely correct, but really counter-intuitive
<gasche>
it's probably not worth bothering with given how arcane it is
<kerneis>
because the case is not so common probably
cdidd has quit [Remote host closed the connection]
<gasche>
so
<gasche>
I think the reason why those need to be filtered out
<gasche>
is that you don't explicitly pass stdlib.cma to the OCaml compiler, it is added in an ad-hoc way there
<gasche>
if ocamlbuild passed stdlib.cma, the usual archive-handling mechanism would handle that
<thizanne>
I suggest something like « Don't deal differently with with stdlib modules »
<thizanne>
-with
<gasche>
(and ocamlc would have to be called with -nostdlib I suppose, but probably this flag does other stuff as well and it wouldn't work)
<gasche>
hi thizanne :)
<thizanne>
hi gasche
<gasche>
maybe "Do not assume the stdlib is available"?
<gasche>
I think most users would be left wondering what "deal differently" means
<gasche>
("deal differently" is not worse than "ignore", but still bewildering)
<thizanne>
I did not dare to change the message that much :)
<gasche>
I vote for keeping the message as it is and concentrating on more pressing issues on ocamlbuild
<gasche>
btw. kerneis I thought more about your patch
<gasche>
(though I'd accept the killer message and it's easy to provide a patch for that)
<gasche>
I'll write on the bugtracker
<kerneis>
ack
cdidd has joined #ocaml
amirmc has joined #ocaml
ygrek has quit [Ping timeout: 245 seconds]
<kerneis>
to conclude my previous issue, I confirm that using ocaml_lib in myocamlbuild.ml + tag use_someexternallib works perfectly
<kerneis>
gasche: for this simple case, (Findlib.query name).Findlib.location is equivalent to Gerd's Findlib.package_directory
<kerneis>
and better than calling "ocamlfind" yourself I guess
<gasche>
I'm not sure how long this half-baked Findlib support will remain in ocamlbuild
<gasche>
I'd rather pay the external call if I were you
<kerneis>
ok
<gasche>
but then I hope we'll get a solution for modularity soon
<kerneis>
:-)
<gasche>
I answered on the .mllib bug
<kerneis>
seen
<kerneis>
does mantis support reply by email?
<gasche>
I don't know
<kerneis>
given the nouser@inria.fr, I guess not
<gasche>
(so that you can yell at me and then pretend your email account was cracked ? ;)
<kerneis>
no, so that I can answer without opening my browser
<introom>
kerneis: my question is given a tuple: (a, b, c, d, ...) and an index n, how to get the nth element ?
<gasche>
you can't do that in a type-safe way
<gasche>
unless your index is statically known
<gasche>
in which case it shouldn't be written as an integer per se
<gasche>
you can define
<introom>
if gasche already known?
<gasche>
let's say
<gasche>
get1_3 : ('a * 'b * 'c) -> 'a
<gasche>
geti_j for any reasonable (i,j)
<gasche>
and then if you know statically (when writing the code) that (n = 3) and the tuple has type (l = 5), instead of your imaginary "get n", write get$n_$l if you want
<gasche>
Batteries provides such accessors for small values of i and j
<gasche>
it's not *obviously* better than let (_a,_b,c,_d) = foo in ... c ...
<introom>
so if I have (3, "23", 2) and I want to get the last val, which is 2, I have to find some battery?
<introom>
or directly write let _, _, last = (3, "23", 2), that seems too trivial.
hkBst has quit [Quit: Konversation terminated!]
cdidd has quit [Quit: Leaving]
<ggole>
If you access particular fields enough that it becomes an issue, you should be using a record.
<gasche>
(or define an accessor function, but yes records are better long-term)
<ggole>
I don't see any objection to static integer tuple accessors myself, but since OCaml doesn't have those, just use what works.
<gasche>
ggole: a single index doens't work well if your types are not implicitly pairs right-nested
<introom>
I used to write python, the slice thing really makes my life comfortable...
<gasche>
you can do the same in OCaml, using lists or arrays
<gasche>
all elements are forced to have the same type... as in python
<ggole>
Eh? Indexing is exactly the accessor that you would write yourself
<gasche>
(type "blurb you don't know anything about")
<ggole>
Except you don't have to bother writing it yourself.
travisbrady has joined #ocaml
<gasche>
ggole: but you have to choose the tuple shape
<gasche>
(right-nested or left-nested of course)
adrien_oww has quit [Remote host closed the connection]
<ggole>
I'm not sure what you mean by nesting: you'd have to do something about inference?
cdidd has joined #ocaml
<ggole>
I guess that would mean another hack like '_a, so maybe it is actually problematic
<ggole>
I was thinking "ATS has those", but of course ATS doesn't have that problem
<whitequark>
I want to do something like: "class foo = object(self) val lst = [self] end"
<whitequark>
but...
<whitequark>
Error: The instance variable self
<whitequark>
cannot be accessed from the definition of another instance variable
<whitequark>
why is that so?
<yezariaely>
I want to use bisect in combination with the OcamlMakefile but I have problems integrating that.
<yezariaely>
I want to have the following calls: ocamlfind ocamlc -package batteries,oUnit,bisect -c -dtypes -g -pp "camlp4o str.cma $BI/bisect_pp.cmo" test.ml
<yezariaely>
Anyone knows how to achieve this?
<yezariaely>
The variable PPFLAGS seems to be wrong.
zshi has joined #ocaml
<zshi>
1
<kerneis>
whitequark: you need to change val to method
<whitequark>
kerneis: I guess I stripped too much
<whitequark>
my original code looks like: val args = List.map (fun ty -> new argument(self, ty)) args_ty
<whitequark>
so I don't want to create new arguments each time I execute the method #args
<whitequark>
I guess the only way to do it is lazy initialization?
zshi has quit [Quit: Lost terminal]
ollehar has quit [Remote host closed the connection]
ollehar has joined #ocaml
<kerneis>
probably
<kerneis>
I don't the reason of this restriction
<gasche>
well
<kerneis>
but probably the reason why recursion is disabled by default
<gasche>
I suppose values are initialized first, and then "self" starts making sense
<whitequark>
gasche: interesting
<gasche>
you don't want to talk about non-fully-complete "self" or you'll shoot yourself in the foot just as C++
<whitequark>
that makes sense indeed
<kerneis>
it looks like this is a more general warning about not being able to reference an instance variable from another one though
<kerneis>
class foo = object(self) val lst = 1 val lst2 = lst end ;;
<kerneis>
fails just the same
<whitequark>
maybe the order of initialization is not well-defined ?
<kerneis>
yes, that's my guess
<kerneis>
and you could initialize with side-effects
<introom>
let f x =x;; List.iter f [1;2;3];; and it fails, why?
cdidd has quit [Ping timeout: 240 seconds]
<kerneis>
raaaaaaah, I hate "make inconsistent assupmtions" at the very end of compiling OCaml
<kerneis>
I don't know what to delete, and I don't want to start from scratch…
<kerneis>
i'm adding corresponding code for mldylib and sending the patch
<gasche>
that's very nice, thank you
djcoin has quit [Quit: WeeChat 0.4.0]
<kerneis>
what i'm not sure is whether the rule should be "cmx & o -> mldylib" or if "cmx -> mldylib" is enough
<kerneis>
(given the fact that the .o will be tested in mldylib -> cmxs anyway)
<kerneis>
it probably doesn't make any difference, just a matter of style about when we fail
<gasche>
whitequark: this seems to be a bug that wasn't present in older versions of OCaml
<gasche>
the file works under 3.12, fails under 4.00.1 and trunk
<gasche>
would you file a bug report?
<gasche>
(by works I mean "fails with a type error")
<whitequark>
gasche: sure. in the meantime, can you please post the type error somewhere?
<whitequark>
because I have no idea why is it not well-typed
<gasche>
File "test.ml", line 15, characters 43-53:
<gasche>
Error: This expression has type < arguments : 'a; .. > * 'b but an expression was expected of type 'c Self type cannot escape its class
fmardini has quit [Ping timeout: 260 seconds]
<gasche>
whitequark: the problem is that the class has no way to describe its own type
<gasche>
but this type would be needed to describe the type of the method "arguments"
<gasche>
you should be able to work around that by adding a type parameter that can talk about this type
<gasche>
class ['a] foo = object (self : 'a) ... end
<whitequark>
gasche: hmm, strange
<whitequark>
why would it need to refer to the type of itself?
<whitequark>
method arguments : argument list
<whitequark>
argument isn't polymorphic, or at least wasn't intended to be
<gasche>
I don't know what "new argument" makes
<whitequark>
the argument class is defined at line 19
<whitequark>
or are you talking about something else ?
<gasche>
oh
<gasche>
you are doing polymorphic recursion
<gasche>
if you take "func" out of the class .. and .. block and define it in a second step
<gasche>
it works
<gasche>
(but I suppose you real-world case really need this recursive circle)
<gasche>
in absence of type annotations, mutually-recursive functions are typed as monomorphic functions (and later generalized)
<gasche>
(because doing otherwise would be undecidable)
<gasche>
hm
<gasche>
in maybe easier to understand words, I mean
<whitequark>
sure, I understood you
osa1_ has quit [Ping timeout: 245 seconds]
<whitequark>
on a second look, I do not think I actually need these class types to be defined recursively
<gasche>
while it's still trying to understand the type of the whole "class .. and .. and" structure, the type-checker picks fresh unknown types for any of the three; in the "new argument(self,...)" case, the unknown type with "argument" is mixed with the type for "self"; this count as an escape of the self type
<gasche>
whitequark: I'm trying two different things
alang__ has joined #ocaml
alang_ has quit [Ping timeout: 260 seconds]
cago has left #ocaml []
introom has quit [Remote host closed the connection]
ygrek has quit [Ping timeout: 276 seconds]
<gasche>
whitequark: so
<gasche>
I think you need polymorhpic recursion, but it's not implemented at the class level in OCaml
<gasche>
the workaroudn is to do open recursion instead: instead of calling "new argument" in your func class, parametrize func over an input that will be instantiated with an argument factory later (when you "tie the knot")
<gasche>
kerneis: what do you mean by "thanks to ocamlbuild lazy approach"?
<kerneis>
just the fact that it doesn't build what it already has
<kerneis>
gasche: probably a poor wording, couldn't think of anything better
<gasche>
ok
zpe has quit [Remote host closed the connection]
<kerneis>
gasche: ocamlbuild/signatures.mli says about [rule]: "the ~tags argument is deprecated, don't use it", but it's heavily used in ocaml_specific.ml!
* kerneis
should stop looking at ocamlbuild's source code
<gasche>
yes
travisbrady has quit [Quit: travisbrady]
<gasche>
we realized that with avsm a few weeks ago
<gasche>
I have a patch from him sitting somewhere to remove all the ~tags from ocaml_specific
<gasche>
we were confused as well
<gasche>
I'll apply it on trunk
<kerneis>
at least that's why I removed it from my newly introduced rules
<gasche>
of course, you were right to do so
<gasche>
in fact
<gasche>
better apply his patch sooner than later, so that you can rebase yours on top of it
<kerneis>
after wondering during 10 minutes and *then* reading the doc :-)
<kerneis>
or you can apply mine and then avsm's, up to you
<whitequark>
it is clear from this that from the argument class, I won't be able to manipulate func-s
<whitequark>
(neither could I do within the window-observer example you linked, *on the base class level*)
<gasche>
kerneis: as I said on the bugtracker, I won't apply yours right away
avsm has quit [Quit: Leaving.]
<kerneis>
ok
<kerneis>
oh, didn't get the email
travisbrady has joined #ocaml
<whitequark>
gasche: so as long as I only want to store the parent link, it's fine... an actual circular dependency between two classes, with method calls and such, seems to be impossible to type
<gasche>
kerneis: if you feel motivated enough (you've surprised me so far), you can add the testsuite stuff
<gasche>
wmeyer's testsuite (in testsuite/, no tests/) is a pleasure to use
<kerneis>
where does it leave?
<kerneis>
ok
<gasche>
so far we've added everything in level0.ml
<gasche>
at some point we'll need to structure that a bit better, but it's fine for now
<kerneis>
not today, but maybe later this week
<gasche>
ok
<gasche>
otherwise I may do it
<kerneis>
if I start working on it, I'll let you know
<kerneis>
if I don't say anything, feel free to go ahead
shinnya has joined #ocaml
csakatoku has joined #ocaml
bkpt has joined #ocaml
pango has joined #ocaml
mort___ has quit [Ping timeout: 245 seconds]
<gasche>
Anil's patch completely removes the ~tags parameter from the interface
<gasche>
I think that for compatibility purposes I'll rather make its use emit a warning -- at least as a first step
<gasche>
(I cringe at the idea of all those users having copy-pasted old stuff in their myocamlbuild.ml suddenly getting a compile error)
<gasche>
the warning text I'm going for so far is the following
<gasche>
"Warning: your ocamlbuild rule %S uses the ~tags parameter, which is deprecated and ignored."
<gasche>
any comments on the wording will be appreciated
skchrko has quit [Remote host closed the connection]
<technomancy>
it's a game loop that takes moves on stdin and prints out board state with printf
<technomancy>
but nothing actually gets printed until the program exits
<technomancy>
how do you force an explicit flush of stdout?
<technomancy>
oh, I tried printf-ing ! instead of %!
<technomancy>
there we go
<technomancy>
I get a lot of non-exhaustive match warnings with that code... is it bad form to match against a list in your arguments like that? (x and y args on line 11, for instance)
zRecursive has left #ocaml []
<xenocons>
technomancy: i think (personally) any warnings are bad, especially pattern exhaustiveness, so while some features can be really nice e.g. let [a;b;d] = [1;2;3], the cost on safety is too damn high
<xenocons>
i would like a way to be able to disable that warning locally, but that probably has issues too
<xenocons>
tbh, i am not sure *why* the compiler can at least try to work out exhaustiveness, most stuff is trivial
<technomancy>
xenocons: I guess a record for x/y would be an easy way to avoid that?
<technomancy>
is there a built-in point type, or should I make my own?
<xenocons>
yeah, but that can look over the top right
<flux>
xenocons, what stuff is trivial? barring the cases where you can just rewrite it as a tuple match..
<technomancy>
flux: oh, so tuples would be better for this due to their fixed length?
<xenocons>
flux: if you only have two elements on the righthand side of an expression, compiler should be able to work out that the binding is exhaustive
<xenocons>
i probably mis-understand the complexity of it though
<flux>
xenocons, sure, but why would you write it that way?
<xenocons>
flux: ive only ever used it for receiving argv
<flux>
technomancy, for coordinates, certainly
<xenocons>
which can be any size i guess
<flux>
xenocons, umm so the compiler is warning exactly correctly :-)
<xenocons>
so it would be impossible for the compiler to work it out i guess
<xenocons>
flux: im still gona argue this
<xenocons>
now, what if you could hint the compiler to max allowed length
<flux>
well, there was this camlp4 syntax extension called pa_refutable.ml or something
<xenocons>
let [a;b] = if x.Length <> 2 then fail else x