<gasche>
also it corresponds with what was idiomatic practice at the time Enum was designed
<gasche>
eg. most of the standard library throws exceptions instead of returning options
<pminten>
so it's mainly a historical issue
<pminten>
thanks
zpe has joined #ocaml
<gasche>
companion_cube and adrien_oww: I think there is no point in asking for "ocaml-ty to be merged upstream"
<gasche>
ocaml-ty is *obviously* not ready for an upstream merge, because we don't have good enough language constructs in most situations
<companion_cube>
i never said it should be merged now
<gasche>
to be mergeable, it needs more work to make it a good system we would want to merge as is
<companion_cube>
but it would be a shame if it was just left rotting in a corner
<companion_cube>
yes
<gasche>
(or more work to cut off the parts that are too hard, and get a nice but less ambitious proposal out of it)
<companion_cube>
pminten: there are people willing to change that ;)
<gasche>
this is completely different in status to the "extensible sum types" work of Leo whose design is, effectively, mergeable today
<companion_cube>
sure
<gasche>
to me the side-mentions that "it would be nice if ocaml-ty was merged upstream" sound like upstream is the bottleneck
<gasche>
while it really is not in this case
<gasche>
(it is in other, eg. format+GADTs or Leo's patch above)
<companion_cube>
is the bottleneck at the disagreement of Alain and Grégoire about the complicated cases (opaquet types)?
<gasche>
there is that
<gasche>
and the fact that the part of the language design meant to emulate type classes isn't really convenient
<gasche>
(at some point the ocaml-ty work branched from "implicit construction of dynamic type representations" to "implicit construction of any type-directed structure", and the latter part is not good enough)
<gasche>
re. opaque types, I've been asking hnrgrgr_ for a blog post, but he's busy with other things
<companion_cube>
I don't understand the "implicit construction of type directed structures"
<companion_cube>
I thought it was a second repo, ocaml-implicit
<companion_cube>
but ocaml-ty as {'a ty; hashtable with 'a ty as keys; automatic inference of 'a ty from context} would already be awesome
<Drup>
pminten: read it, it should make some stuff clearer
<pminten>
Drup: already reading it :)
<companion_cube>
we can discuss it here if you have questions
aurynj has joined #ocaml
diginux_ is now known as diginux
<pminten>
ok, so if I understand it correctly c-cube sequence is effectively like a reduce/fold based approach but instead of passing an accumulator and returning an accumulator you use side-effects
<Drup>
you use side-effects ?
<Drup>
not really
<Drup>
not for Sequence, at least
<Drup>
well, you can
<pminten>
type 'a t = ('a -> unit) -> unit
<Drup>
but you don't have to
<pminten>
so I guess there's refs in there
<Drup>
right
<Drup>
you don't need refs, technically
nikki93 has joined #ocaml
<Drup>
it's just that the only operation you can apply to your stream
<Drup>
is iterating on it
<Drup>
it's a bit weird the first time, but I advise you to read the code and it's quite clear how it works
<Drup>
(if you are interested)
<pminten>
which is related to the fact that you'd get annoying typing issues if you try to write type ('a, 'acc) t = ('a -> 'acc -> 'acc) -> 'acc
arj has quit [Quit: Leaving.]
<pminten>
I'm starting to understand how this works, you need refs but you only need them in a few functions
<pminten>
once you define fold you can implement a lot of things in terms of that
Hannibal_Smith has quit [Quit: Sto andando via]
<companion_cube>
pminten: I could have used a fold, indeed
<companion_cube>
rather than a "iter" function
<Drup>
companion_cube: time to build a new wheel :3
<companion_cube>
nah
<pminten>
companion_cube: wouldn't you get a problem with a sequence from a list being different from a sequence from an array typewise?
<companion_cube>
pminten: that's the whole point, once you have a sequence it doesn't matter where it comes from
<companion_cube>
it's just a closure ('a -> unit) -> unit
<pminten>
companion_cube: exactly, that's why I think a fold based approach wouldn't work
<companion_cube>
nah, it would be a function 'b. ('b -> 'a -> 'b) -> 'b -> 'a
<companion_cube>
but... probably wrapped in a record for the universal 'b.
<companion_cube>
(sadly)
<Drup>
pminten: Gen is a more traditionnal stream
<pminten>
hmm, yeah, that'd work
arjunguha has joined #ocaml
<pminten>
Drup: looks like what I've come up with as a device for explaining enums (i.e. the most simple approach so that I can later point out the benefits of Enum over it)
<Drup>
yeah, it's very simple :D
<pminten>
though I do wonder if some of the complexity of Enum doesn't have it's place, I mean a fast count function comes in very handy sometimes
<pminten>
I suspect there's actually somewhat of a tower of enumeration types, with Sequence and Gen being at the base (simplest)
<Drup>
do you have an example where you really need a counting function for a lazy imperative stream ?
<pminten>
not for a lazy stream
<Drup>
and where it wouldn't be more simple to count yourself
<Drup>
if you don't want a lazy stream, use something not lazy then ^^'
<companion_cube>
Drup: it can be useful if you do Array.enum foo |> Enum.map f |> Array.of_enum
<Drup>
yeah, right :/
<pminten>
..., yeah, can't think of anything specifically
<companion_cube>
but it breaks as soon as you use something like Enum.filter/Enum.flatMap
<companion_cube>
in which case you have to count explicitely
<Drup>
pminten: I though the same at the beginning
<Drup>
then I tried to find some good use cases
<companion_cube>
Enum has good reasons to provide fast count
<Drup>
and Enum has good reasons to be clonable, yes
<pminten>
companion_cube: but are those reasons related to the problem domain or to the specific implementation of Enum?
<Drup>
but it stills make it slow and super complicated
<companion_cube>
but in most cases I think it's simpler and faster to have Gen, and maybe make it "persistent" if you need to count/clone
<companion_cube>
pminten: the problem domain
<companion_cube>
but it makes the semantics very complex to handle
<companion_cube>
and to test
<Drup>
(and the implementation is impossible to understand)
<pminten>
in my experience 90% of all use of Elixir's Enumerable (which is pretty much like Gen) are map, filter, reduce
<pminten>
and this is likely the same in any language
<Drup>
yep
dsheets has quit [Ping timeout: 264 seconds]
<companion_cube>
and flatmap
<pminten>
that too
<companion_cube>
so yeah, speed and simplicity imho trump other features
<companion_cube>
for instance, BatArray.of_gen needs to 1/ convert gen to list 2/ array.of_list 3/ rev array
<pminten>
I'd put it like this: it's not a big deal if an operation like filter makes counting the collection take more time
<companion_cube>
whereas it can be done in one traversal with Enum
<companion_cube>
(iff it has fast_count)
<Drup>
Enum's feature would be worthwhile if Enum's performance where in the same magnitude as the others
<Drup>
but it's not the case
<companion_cube>
yeah, exactly
<companion_cube>
and also, testing is too hard
<pminten>
the problem with Enum's features is that they aren't really all about enumerations but some are more related to sequences
<pminten>
or more exactly not all of the features are related to simple forward iteration
<Drup>
pminten: I'm going to take my plane now, but if you are willing to write a blog post about the various streams library and their strong and weaknesses, I will be happy to participate
<Drup>
strength*
<pminten>
I think I'll first need to learn a lot more before even thinking about that ;)
<Drup>
:D
tobiasBora has joined #ocaml
ulfdoz has quit [Ping timeout: 252 seconds]
ollehar has quit [Ping timeout: 252 seconds]
nikki93 has quit [Ping timeout: 240 seconds]
pminten has quit [Quit: Leaving]
arjunguha has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
talzeus has joined #ocaml
rand000 has joined #ocaml
Tamae has joined #ocaml
Patchou has quit [Ping timeout: 255 seconds]
talzeus has quit [Read error: Connection reset by peer]
introom has joined #ocaml
aurynj has quit [Quit: Leaving]
rand000 has quit [Ping timeout: 253 seconds]
<elfring>
How should it be determined in OCaml source code where a function ends?
<companion_cube>
in well written code, by indentation
<companion_cube>
in the toplevel with ;;
<companion_cube>
elfring: basically one function = one expression
<companion_cube>
(well, one fun x y z -> expression)
RMacy has joined #ocaml
<ggole>
Some editors provide a means to move across function boundaries
<elfring>
Is it still "basic" to spot a function end if an expression defines subfunctions and condition checks?
<companion_cube>
indentation is here to help, provided the code is good
RMacy has quit [Ping timeout: 252 seconds]
<ggole>
Usually clearly written code will use lexical conventions to make it more clear in practice
<ggole>
Such as leaving one (or two) lines of space after every function
ygrek has quit [Ping timeout: 240 seconds]
ulfdoz has joined #ocaml
nikki93 has joined #ocaml
hto has quit [Ping timeout: 255 seconds]
hto has joined #ocaml
ollehar has joined #ocaml
<Drup>
(and also, practice to now the ocaml grammar, it's pretty obvious when a function ends if you are looking for it
ollehar1 has quit [Ping timeout: 240 seconds]
introom has quit [Read error: Connection reset by peer]
RMacy has joined #ocaml
RMacy has quit [Ping timeout: 252 seconds]
<mrvn>
companion_cube: an ocaml function ends when there is no possibly syntactically and gramatically correct way to make it longer.
<companion_cube>
indeed
<companion_cube>
it's only relevant for ";" chains, which are as long as possible
<mrvn>
Compared to C like languages that have a closing } or python with its end of indentation this is a hard problem in ocaml I think.
<mrvn>
for toplevel functions I guess you could scan for "let" or "end" and for nested functions you scan for "in".
<mrvn>
but does that catch everything?
<companion_cube>
"in" closes the current expression down to the previous "let"
ulfdoz has quit [Ping timeout: 240 seconds]
<companion_cube>
but thre is still a nesting problem, it's not that easy to read
<mrvn>
same with extra {} in C functions
introom has joined #ocaml
nikki93 has quit [Ping timeout: 240 seconds]
aurynj has joined #ocaml
tane has joined #ocaml
elfring has quit [Quit: Konversation terminated!]
dlat has quit [Ping timeout: 255 seconds]
tnguyen has quit [Quit: Leaving]
seggy has joined #ocaml
segmond has quit [Ping timeout: 255 seconds]
elfring has joined #ocaml
igitoor has quit [Remote host closed the connection]
igitoor has joined #ocaml
ygrek has joined #ocaml
seggy is now known as segmond
tnguyen has joined #ocaml
igitoor has quit [Changing host]
igitoor has joined #ocaml
ddosia has joined #ocaml
ulfdoz has joined #ocaml
<ddosia>
Hi guys, can't manage how to force merlin to do "open Core.Std"
<ddosia>
already did "PKG core" in my .merlin file, but with no success
<Kakadu>
have you set S and B?
<ddosia>
I mean in vim I am able to press <leader>-t and see types from original say List.map but not from Core.Std
<ddosia>
Kakadu: yes I did
<ddosia>
s .
<ddosia>
B _build
<ddosia>
s/s/S/g
<ddosia>
e.g. for String.concat it gives me "string -> string list -> string" and not a "?sep:string -> string list -> string"
<Kakadu>
does it work if you don't use open and use full path ?
introom has left #ocaml []
<ddosia>
Kakadu: what do you mean?
ulfdoz has quit [Ping timeout: 264 seconds]
nikki93 has joined #ocaml
dsheets has joined #ocaml
wolfnn has joined #ocaml
<rks`_>
ddosia: add "FLG -debug protocol,/tmp/merlin.log" to your .merlin
<rks`_>
then try again to type/complete with core and paste the log file somewhere
<rks`_>
and what Kakadu meant was "try to complete on Core.Std.L"
<rks`_>
(which is another good way to find the problem)
pango has quit [Quit: Client exiting]
ddosia has quit [Ping timeout: 240 seconds]
shinnya has quit [Ping timeout: 255 seconds]
pango has joined #ocaml
nikki93 has quit [Ping timeout: 264 seconds]
bjorkintosh has quit [Ping timeout: 240 seconds]
bjorkintosh has joined #ocaml
ddosia has joined #ocaml
<ddosia>
rks`_: when I add FLG... to .merlin after vim restart seems that nothing has occured inside /tmp/merlin.log
<ddosia>
also if I try to do type detection on Core.Std.String.concat I see correct result
<ddosia>
(but empty file was created)
<adrien>
gasche: I'm very sad: by commiting the patch for Printexc' raw backtraces and current call stack without complaining about the lack of @since in the documentation, you've made me believe I could use it in yypkg
ddosia has quit [Ping timeout: 240 seconds]
<rks`_>
oh, he left.
<def-lkb>
pan.
<gasche>
adrien: sorry :p
<gasche>
on the plus side, it allowed Daniel to whine infinitely about the fact that he has to parse the string back
<gasche>
(not the lack of @since, the function)
<adrien>
heheh :P
<adrien>
actually, if I were him, I'd probably have added an "external" to my source code; it seems doable to get the "something array option" and handle it :)
<adrien>
(did you say "it's dirty"?)
<adrien>
gasche: and, well, on the plus side, not having that function got me rid of the need for Printf.ikfprintf which is not widespread enough for me to use
alinab has joined #ocaml
<rks`_>
haha
<rks`_>
« on the plus side: since I cant use X, I cant use Y »
<rks`_>
makes sense.
<adrien>
nah: since I can't use X, I have no need for Y which wasn't available
<adrien>
so I'm only sad once, not twice :)
ygrek has quit [Ping timeout: 252 seconds]
seggy has joined #ocaml
segmond has quit [Ping timeout: 240 seconds]
boogie has joined #ocaml
ulfdoz has joined #ocaml
nikki93 has joined #ocaml
ygrek has joined #ocaml
yacks has quit [Ping timeout: 264 seconds]
nikki93 has quit [Ping timeout: 240 seconds]
Hannibal_Smith has joined #ocaml
ddosia has joined #ocaml
<def-lkb>
ddosia: I pushed the feature you requested on ocp-indent-vim, tell me if this is what you expected
ddosia has quit [Ping timeout: 240 seconds]
ulfdoz has quit [Quit: deprecated]
ulfdoz has joined #ocaml
zpe has quit [Remote host closed the connection]
zpe has joined #ocaml
zpe_ has joined #ocaml
zpe has quit [Read error: Connection reset by peer]
nikki93 has joined #ocaml
ygrek has quit [Ping timeout: 240 seconds]
<gasche>
def-lkb: you told me the ocamllex stuff was the first of the potentially-mergeable things in Merlin
<gasche>
I'm waiting for the next :]
<def-lkb>
gasche: :'
tobiasBora has quit [Read error: Connection reset by peer]
<adrien>
:D
tianon has quit [Ping timeout: 252 seconds]
tianon has joined #ocaml
dant3 has quit [Ping timeout: 245 seconds]
nikki93 has quit [Ping timeout: 240 seconds]
dant3 has joined #ocaml
zpe_ has quit [Remote host closed the connection]
zpe has joined #ocaml
tianon has quit [Ping timeout: 240 seconds]
ggole has quit [Ping timeout: 252 seconds]
zpe has quit [Ping timeout: 240 seconds]
rand000 has joined #ocaml
tianon has joined #ocaml
zpe has joined #ocaml
<elfring>
I have constructed another source code example for my evolving needs. The application "OCamlEditor 1.9.0" shows me that too many arguments would be applied to a specific function. But when I copy the "questionable" source
<elfring>
I have constructed another source code example for my evolving needs. The application "OCamlEditor 1.9.0" shows me that too many arguments would be applied to a specific function.
<elfring>
But when I copy the "questionable" source code into a OCaml command line interface (toplevel) it gets accepted and can be exeuted there. Do you have got similar experiences?
divyanshu has joined #ocaml
bjorkintosh has quit [Ping timeout: 264 seconds]
tnguyen has quit [Quit: Leaving]
bjorkintosh has joined #ocaml
divyanshu has quit [Quit: Computer has gone to sleep.]
divyanshu has joined #ocaml
zpe has quit [Remote host closed the connection]
zpe has joined #ocaml
zpe has quit [Ping timeout: 240 seconds]
nikki93 has joined #ocaml
zpe has joined #ocaml
WraithM has quit [Ping timeout: 255 seconds]
algoriddle has joined #ocaml
zpe has quit [Remote host closed the connection]
zpe has joined #ocaml
lordkryss_ has joined #ocaml
zpe has quit [Ping timeout: 240 seconds]
nikki93 has quit [Remote host closed the connection]
<Drup>
elfring: can you show the questionable code ?
<Drup>
(I don't use OCamelEditor, but it may be interesting)
WraithM has joined #ocaml
Simn has quit [Quit: Leaving]
tlockney_away is now known as tlockney
Hannibal_Smith has quit [Quit: Sto andando via]
zpe has joined #ocaml
Kakadu has quit [Quit: Konversation terminated!]
WraithM has quit [Ping timeout: 240 seconds]
<tobiasBora>
Hello,
zpe has quit [Remote host closed the connection]
zpe has joined #ocaml
<tobiasBora>
I would like to try to use ocamlviz, so I installed it with apt-get (I even tried with opam), but it cannot be find, I've an error "Error: Unbound module Ocamlviz"
<tobiasBora>
ocamlfind list | grep viz doesn't give me anything
zpe has quit [Ping timeout: 240 seconds]
tobiasBora_ has joined #ocaml
tobiasBora has quit [Ping timeout: 264 seconds]
axiles has quit [Remote host closed the connection]
<tobiasBora_>
I managed to compiled but a strange thing happened : when I use Unix.sleep alone it works, but when I add Ocamlviz.init;; the program doesn't wait anymore...
ulfdoz has quit [Ping timeout: 240 seconds]
<Drup>
tobiasBora_: I only heard about ocamviz, but it seems very badly packaged
<tobiasBora_>
Ok...
<Drup>
anyway, what do you need to profile ? prof does a good job for ocaml if you use one of the -fp switches
<elfring>
I should have commented a line out after the working source code. I hope that I can improve my knowledge also around OCaml error messages.
<tobiasBora_>
It compiles well with ocamlopt +I ocamlopt, but I can't manage to use it with ocamlfind...
<tobiasBora_>
(which is used in a big project...)
<tobiasBora_>
Drup: I would like to follow the memory in real time...
<Drup>
in real time ? huuum
<Drup>
there is the switch for memory allocation, but I don't think it's in real time
<tobiasBora_>
Graphviz seems to be a quite powerfull tool... What does exactly +I ?
<Drup>
graphviz is a format to describe graphs :p
<tobiasBora_>
Hum I mean ocamlviz ^^
<tobiasBora_>
(which uses graphviz)
<Drup>
-I for the compiler is just "include this directory when you search for .cm[..]"
<tobiasBora_>
Ok. And ocamlopt shouldn't do it by himself when it's in /usr/lib/ocaml/ ?
<Drup>
if it's in the stdlib, yes
<Drup>
otherwise, no, that's why you use findlib
talzeus has joined #ocaml
<Drup>
(except if you added stuff in the stdlib's directories, but that's dirty)
Arsenik has joined #ocaml
talzeus has quit [Remote host closed the connection]
talzeus has joined #ocaml
<tobiasBora_>
Drup: I see... And how could I do the same thing as +I with ocamlfind ?
<Drup>
usually, you don't need to
<Drup>
"-package foo" is enough
<Drup>
and if a package doesn't use ocamlfind, as ocamlviz seem to
<Drup>
crucify the author
<Drup>
(and file a bug report)
<tobiasBora_>
Ok thank you ^^ Is there a way to manually add a folder to ocamlfind (just pending I crucify the author)
<Drup>
-I
<tobiasBora_>
And how can a lib say to ocamlfind "I I'm here" ?
<Drup>
"ocamlfind ocamlopt" accepts all the option that ocamltop accept
<Drup>
ocamlopt*
<Drup>
tobiasBora_: ocamlfind install
<Drup>
(or use oasis and don't bother about those pesky details)
tane has quit [Quit: Verlassend]
zpe has joined #ocaml
<tobiasBora_>
Ocamlfind install and opam install should have the same result ?
<Drup>
opam merely uses the build system that the package use
elfring has quit [Quit: Konversation terminated!]
<Drup>
if the package is done poorly (without ocamlfind support)
<Drup>
opam can't do anything about it
zpe has quit [Ping timeout: 264 seconds]
xianxu has joined #ocaml
<tobiasBora_>
And ocamlfind install should do manually what the package is supposed to do automatiquely ?
<Drup>
what are you trying to do ?
<Drup>
ocamlfindify ocamlviz ?
darkf has joined #ocaml
<tobiasBora_>
Just understand the difference between ocamlfind install and opam install ^^
<Drup>
ocamlfind install is something local
<dsheets>
ocamlfind install puts specific files in a specific location including the META file specifying basic information about the installed files
<dsheets>
opam install solves, downloads, and builds package version installation requests
<Drup>
thanks dsheets x)
<Drup>
I was getting unclear :D
<dsheets>
hope i didn't step on your toes there
<Drup>
on the contrary :p
aurynj has quit [Quit: Leaving]
<tobiasBora_>
Thank you ^^ And only programms with the META file can be "ocamlfind-installed", or I can install any library like this ?
<Drup>
you need a META
<Drup>
concerning ocamlviz
<Drup>
I think it should be pretty easy to oasisify it
rand000 has quit [Quit: leaving]
<tobiasBora_>
It's clearer now ! And you talk about oasis, what is it, it's the first time I heard about.
<Drup>
really ?
<Drup>
that's surprising
<tobiasBora_>
Yes :-°
<Drup>
tobiasBora_: have you done some Haskell ?
<tobiasBora_>
no sorry
<Drup>
ok
<Drup>
then, oasis is a "meta" build system
<Drup>
it handles all the high level description of your package
<Drup>
and generate the appropriate configuration for a build system (ocamlbuild)
<Drup>
it also handles all the packaging job for you
<tobiasBora_>
What kind of packaging ? apt-get or opam ?
<Drup>
ocamlfind, for first
<dsheets>
ocamlfind < ocamlbuild < make < oasis < opam approximately
<dsheets>
with the actual toolchain sitting below all that
<Drup>
dsheets: ocamlbuild handle the use of ocamlfind
<Drup>
not the instalation
<dsheets>
yes, that is an ordering for build
<dsheets>
and every single one of those tools is optional
<tobiasBora_>
It seems to be really nice !
<Drup>
what I mean by "oasis handle the packaging" is that it will take care of the bureaucracy for ocamlfind installation and that there are translators to generate deb or opam packages
<dsheets>
tobiasBora_, some bits are nicer than others and there is some duplication and partial functionality
<Drup>
it comes with a partial loss of control over the build system
<Drup>
which can be a pain sometime if you want to do delicate stuff
lordkryss_ is now known as lordkryss
<Drup>
(but imho, most of the issues with oasis are actually issues with ocamlbuild)
<tobiasBora_>
And you cannot modify it by yourself ?
<Drup>
you can
<dsheets>
oasis generates a lot of code
<tobiasBora_>
And oasis autodetect libraries ?
<dsheets>
autodetect?
aurynj has joined #ocaml
<tobiasBora_>
I had a look in the quickstart doc, and I never see any question about dependencies, so should I tell "The dependencies are..." or does oasis dectect them ?
Leonidas_ is now known as Leonidas
<dsheets>
tobiasBora_, you must specify dependencies in _oasis
<dsheets>
you can probably get pretty close but i'm not really sure what the point would be
<Drup>
(and if you add effectful modules in the mix ...)
<Drup>
tobiasBora_: yes
<tobiasBora_>
I don't understand why it should be impossible to detect, when I compiled and I've "unbound module Parmap", Ocaml see that it need Parmap no ? ^^
<Drup>
tobiasBora_: Parmap is the module name
<dsheets>
Drup, effectful modules don't change the expected interfaces
<Drup>
dsheets: lablgtk2.auto-init, for example.
<Drup>
you can expect it to be there in your code, you still never call
<Drup>
call it*
<Drup>
tobiasBora_: Parmap is the name of the module
<dsheets>
Drup, ah, sure, yes you'd miss those. I would argue that that design is particularly poor because the code does not actually mention its assumptions
<Drup>
(I agree :p)
<Drup>
you would have issue with stuff like Core, though
<Drup>
"I'm using List with labels"
<tobiasBora_>
Drup: You mean that with the module name it's not possible to know the whole package name ?
<Drup>
tobiasBora_: because there is no maping package <-> module
<Drup>
and there can't be
<Drup>
see the previous example with List
<tobiasBora_>
I see ^^
<dsheets>
sure there can, it's just not one-to-one
<tobiasBora_>
But a "default" choice could be proposed :-°
<Drup>
yeah
<dsheets>
and in a large number of cases, you can deduce only a single known module that would satisfy some source
<Drup>
you could get pretty close to a good proposition
<dsheets>
but again, i'm not sure why you can't just specify them...
<Drup>
but it would be a lot of work for a very fragile system
<Drup>
knowing your dependecies is good anyway.
<dsheets>
oh, i think it would just be to bootstrap your metadata
<dsheets>
not "here's some random code, i hope the heuristics work for you!"
Arsenik has quit [Remote host closed the connection]
Thooms has quit [Ping timeout: 240 seconds]
<tobiasBora_>
Yes ^^ And when you want to share a project, you always use oasis or it's more a funny tool ?
<Drup>
I always use oasis
<tobiasBora_>
Ok, I think I will give it a try !
<Drup>
(even if I'm just doing something quick, I find it easier to do an _oasis than to use a Makefile)
<Drup>
(but I'm in very bad terms with make)
<tobiasBora_>
I see... Me I passed 2h to make my own "good" (for me) makefile and I always paste it when I create a new project, but I think it's quite ugly !
<Drup>
well, do you use ocamlfind ? :3
<tobiasBora_>
Yes
<Drup>
even for installation ? :]
<tobiasBora_>
You mean ? When I can install a package from the repo (apt-get) I use apt-get, if not I use opam.
<Drup>
no, for installation of your library !
<tobiasBora_>
Oh sorry ^^ For the moment I don't give an easy way to install my library (in the same time I have made only one "real" library), because I didn't know how to do it properly ! No I know, thank you ;)
<tobiasBora_>
What should I answer to plugin ? What is it for ?
<Drup>
if you want to learn oasis, I advice you to read lwt's _oasis
<Drup>
oasis is one of those thing that are better learned by examples.
<Drup>
(and lwt is a nice and complete example)
lordkryss has quit [Quit: Connection closed for inactivity]
<tobiasBora_>
Ok. Just a last question : the common way to add a dependencies is to manuall edit _oasis ?