hellome has quit [Remote host closed the connection]
Nahra has quit [Ping timeout: 245 seconds]
Nahra has joined #ocaml
watermind has quit [Quit: Konversation terminated!]
chrisdotcode has quit [Ping timeout: 264 seconds]
csakatoku has joined #ocaml
demonimin has quit [Remote host closed the connection]
demonimin has joined #ocaml
hellome has joined #ocaml
Neros has quit [Ping timeout: 264 seconds]
avsm1 has joined #ocaml
q66 has quit [Quit: Leaving]
avsm has quit [Ping timeout: 260 seconds]
madroach has quit [Ping timeout: 264 seconds]
ygrek has joined #ocaml
madroach has joined #ocaml
chrisdotcode has joined #ocaml
Nahra has quit [Ping timeout: 245 seconds]
dsheets has quit [Ping timeout: 248 seconds]
Nahra has joined #ocaml
walter|r has joined #ocaml
walter has quit [Read error: Connection reset by peer]
ygrek has quit [Ping timeout: 245 seconds]
manud has joined #ocaml
walter|r has quit [Read error: Connection reset by peer]
Nahra has quit [Quit: leaving]
avsm1 has quit [Quit: Leaving.]
travisbrady has joined #ocaml
ygrek has joined #ocaml
darkf has joined #ocaml
avsm has joined #ocaml
shinnya has quit [Ping timeout: 264 seconds]
BiDOrD_ has joined #ocaml
BiDOrD has quit [Read error: Operation timed out]
demonimin has quit [Ping timeout: 246 seconds]
avsm has quit [Quit: Leaving.]
ollehar has joined #ocaml
introom has joined #ocaml
yacks has quit [Ping timeout: 264 seconds]
travisbrady has quit [Quit: travisbrady]
yacks has joined #ocaml
ollehar has quit [Ping timeout: 260 seconds]
avsm has joined #ocaml
ollehar has joined #ocaml
introom has quit [Ping timeout: 246 seconds]
avsm has quit [Ping timeout: 256 seconds]
manud has quit [Ping timeout: 246 seconds]
ollehar has quit [Ping timeout: 264 seconds]
avsm has joined #ocaml
manud has joined #ocaml
milosn has joined #ocaml
milosn_ has quit [Ping timeout: 240 seconds]
cdidd has quit [Ping timeout: 248 seconds]
introom has joined #ocaml
ollehar has joined #ocaml
yacks has quit [Quit: Leaving]
cdidd has joined #ocaml
ygrek has quit [Remote host closed the connection]
ygrek has joined #ocaml
manud has quit [Ping timeout: 268 seconds]
lifeng has quit [Quit: Ex-Chat]
wmeyer has joined #ocaml
<wmeyer>
pin adrien
bobry has quit [Ping timeout: 240 seconds]
<levi>
wmeyer: Heya
<wmeyer>
levi: hey, I just wanted to ping you too
* adrien
hides :P
<adrien>
morning
<adrien>
I've started rebasing some of the patches and I still need to rebase one and apply two others (which should apply without issue)
<wmeyer>
morning
<levi>
wmeyer: I've been working on the configuration stuff. It turns out the failure on my machine was not related to the config file at all. :)
<wmeyer>
do it gradualy, package of 3 is fine usually adrien
<adrien>
however I'm going to rework the remaining patches; some needs to be merged and some need to be split
<wmeyer>
levi: possibly I may did i see that before, but I don't remember what was it, have you pinned that down the problem?
<levi>
wmeyer: It was actually due to my machine's hostname not showing up in /etc/hosts, so gethostbyname was bailing.
<wmeyer>
!
<wmeyer>
yes
<adrien>
I'll be swimming this evening so I won't have much time but I'll probably send something on tomorrow
<adrien>
almost done :P
<wmeyer>
i remember this kind of problem, but i have to admit didn't get to the root of the problem levi
<wmeyer>
so thanks for finding this out
<wmeyer>
we may want to raise a bug for ocaml unix module or add this information to Indigo wiki
<levi>
I found it through moving a printf around until I figured out exactly which call was the last to execute.
<wmeyer>
levi: good job, thanks.
<levi>
I don't think it's actually a bug; it's throwing an exception because the underlying call failed, which is what it says it'll do.
<levi>
It just needs to be wrapped in a lwt_try
<wmeyer>
the user definitely neesds to know
<wmeyer>
if you can provide a nice error message would be good
<levi>
Speaking of which, what problem did you experience with Bolt?
<wmeyer>
I don't clearly remember
<wmeyer>
it was long time ago
<wmeyer>
we need to talk a bit, what needs to be done in Indigo
<levi>
I wonder if it was a bad interaction with lwt?
<wmeyer>
yes, that's possible
<levi>
I haven't looked in depth at how lwt is being used overall, but if something else starts making blocking system calls it can mess up lwt's monadic thread switching.
<levi>
lwt has a logging facility built into it; Bolt seems a lot more featureful, but I'm not sure how much logging you really want.
<wmeyer>
maybe dropping this dependency would be OK and use Lwt logging, because we always tend to stay in Lwt anyway
<wmeyer>
adrien: no problem, when you have your patches ready just let me know
<wmeyer>
I am glad somebody is interested in Indigo :-)
<wmeyer>
ping def-lkb_ :-)
<wmeyer>
levi: I have to admit the bulk of huge work is behind us, especially custom drawn gui
<wmeyer>
i'd like to use reactive programming for this
<wmeyer>
other maybe difficult part is to provide a really nice API for scripting
<wmeyer>
so maybe one of the first things would be to port few modules from Vassal engine
<levi>
What kind of 'things' do you want to be placed on the 'tabletop'?
<wmeyer>
the candidates are clear: "Bucket of Dice", "Carcassone" at least first two
<wmeyer>
has to be very generic, and at the same time convenient
<levi>
Yeah.
<wmeyer>
:)
<wmeyer>
I have a detailed spec and know guy who knows what he is doing
<wmeyer>
but it's a big document in Polish
<wmeyer>
i am going to raise mantis issue and try to translate at least partially
<levi>
I can at least work on things like command line parsing and logging infrastructure. :)
<wmeyer>
the spec is not complete but rather a nice collection of ideas
<wmeyer>
(mantis=github)
<wmeyer>
levi: that's good, thanks, but we will definitely have much more interesting work than this too!
<wmeyer>
i am scared about gui at the moment
<levi>
I have put together a prototype of a cmdliner-based command line reader for both client and server, and a means for merging config from files and the command line.
<wmeyer>
levi: I really want Indigo to be used to full extent :-)
<wmeyer>
oh cmdliner, great!
<wmeyer>
i was just thinking to propose it ...
<levi>
Though it probably will need to be replaced with something more general when there's actual game stuff that needs configuration too.
<levi>
Or maybe that would be entirely separate config. Who knows?
<wmeyer>
levi: I think it would be good to allocate some time on the weekend, and try together VASSAL engine, to show you what it is
<levi>
Sounds good.
<wmeyer>
levi: there might be some input for game plugins through command line, you are right
<wmeyer>
but I'd like to avoid too much command line at least on client side
<wmeyer>
and just use it for the stuff that allows to quikclu operate
<adrien>
what's Indigo?
<levi>
At the moment, it has default for everything and also has provisions for reading overrides to the defaults from either a config file or the command line.
<wmeyer>
I know you are different time zone levi, what time you are now?
<levi>
11:35 pm right now.
<wmeyer>
levi: yes, i tried my best to implement it propery
<wmeyer>
so it's 7h as I though
<wmeyer>
Ok, maybe your late night and my early morning would be good
<wmeyer>
adrien: it's a tabletop engine
<levi>
Well, I was referring to my new cmdliner-based prototypes.
<wmeyer>
ah ok
* wmeyer
still sleeping
<adrien>
you have a link? :P
<wmeyer>
levi: I'd like to use as much libraries as we need/want
<adrien>
you have a link?
<levi>
I am still getting my bearings in OCaml-land again.
<wmeyer>
levi: definitely you have a really good start!
<adrien>
thanks
<levi>
I'm pretty sure there were no polymorphic variants last time I used it, and certainly not GADTs. Probably not any monad libraries, either, not that I had any idea what a monad was back then.
<wmeyer>
levi: sounds like it was long time ago
<wmeyer>
at least polymorphic variants have been around quite some time
<wmeyer>
levi: I am sure you like OCaml more now :-)
manud has joined #ocaml
<wmeyer>
feel free to use any feature you think it's reasonable
<wmeyer>
(including GADTs)
<wmeyer>
for monads you can use (berware, self advertising): https://github.com/danmey/omonad - it works with the trunk compiler
<whitequark>
wmeyer: what does it require from the compiler?
<wmeyer>
whitequark: just -ppx rewriters support
<wmeyer>
(and compilerlibs)
ggole has joined #ocaml
<wmeyer>
levi: I think we can quickly run VASSAL engine on saturday
<wmeyer>
I still have to fix my desktop
<whitequark>
wmeyer: what could I use omonad for?
<wmeyer>
so tentatively saturday evening, or other time you wish
<wmeyer>
sunday is good too, but i am going for a beer later in the evening
<wmeyer>
whitequark: any monadic programming
<whitequark>
wmeyer: sure. I just wonder about practical use cases in ocaml.
<wmeyer>
whitequark: not as many as in Haskell but still!
<levi>
whitequark: monads are useful for modeling and composing kinds of 'computation' as separate from pure values.
<whitequark>
levi: well, I kind of understand that in theory it is
<levi>
They were first used in CS not directly in programming languages but in denotational semantics.
<whitequark>
can you show any examples where it's more convenient for some relatively common task?
<levi>
Well, consider the 'option' type constructor. It can (with the proper 'return' and 'bind' operations) form a monad, and in the option monad you can work with values without having to explicitly check for failure all the time.
<whitequark>
right
<whitequark>
but can't I use the Option.map from extlib for pretty much the same result?
<wmeyer>
list comprehension monad, it allows to construct and enumerate lists, including simple constraint solving
<whitequark>
and yeah, I understand that option/Option implement a monadic interface
<whitequark>
I just don't get what would you need a dedicated library for
<wmeyer>
you need a syntax actually not a library
<whitequark>
hm
<wmeyer>
is much more convenient
<whitequark>
so it just provides a syntax which is the same for all monadic interfaces?
ygrek has quit [Ping timeout: 264 seconds]
<wmeyer>
yep
<whitequark>
like option
<whitequark>
ah I see, thanks
<wmeyer>
you say
<wmeyer>
levi: when you are done with your stuff, just submit a pull request
<wmeyer>
I will review, test it, and merge it ASAP
<whitequark>
wmeyer: I say?
<wmeyer>
you say:
<levi>
wmeyer: Sure. I'm going pretty slow at the moment, as I am still spending a lot of time scratching my head and reading code.
manud has quit [Ping timeout: 264 seconds]
<wmeyer>
x <-- foo ();
<wmeyer>
y <-- return "bar";
<wmeyer>
z <-- x ++ y;
<wmeyer>
return z
<wmeyer>
you see, no explicit option handling
<wmeyer>
but when foo returns None
<wmeyer>
the whole sequence of assigments will return none
<wmeyer>
before it gets the next statement
<wmeyer>
so it's like an exception
* whitequark
nods
<wmeyer>
levi: certainly the code is not obvious in many place
<wmeyer>
i am happy to see any (even small) improvements too
<levi>
whitequark: Monadic programming is kind of like programming in continuation-passing style, but with 'bind' stuck between each function and its continuation. This lets you reprogram the semantics of your monadic code block. The syntactic support 'un-CPSs' it.
<levi>
This is what is meant when people say that monads are like 'programmable semicolons'.
manud has joined #ocaml
<whitequark>
interesting interpretation
<levi>
In fact, you can easily make a continuation monad that lets you capture and invoke delimited continuations in your monadic block.
ggole has quit [Read error: Connection timed out]
ggole has joined #ocaml
ben_zen has joined #ocaml
lopex has quit [Ping timeout: 264 seconds]
wmeyer has quit [Ping timeout: 260 seconds]
wmeyer has joined #ocaml
<wmeyer>
whitequark: I will add that monads are generic interface to computation
<wmeyer>
whitequark: the return operation allows you to include more information and abstract the
<wmeyer>
data type
<wmeyer>
whitequark: and bind allows to customize how the computation behaves
<levi>
Another interesting thing is the idea of the 'free monad' for a monadic type. This is the minimal form of a monad, which doesn't provide any additional structure beyond that required by the monad laws. What it typically ends up giving you is a data structure representing the 'shape' of the computation in your monadic code block, which you can later interpret via a fold-like operation.
csakatok_ has joined #ocaml
<whitequark>
so, in the case of ocaml, if I write a code block using a free monad, it'll turn into a list of thunks?
<levi>
A 'free' structure is the simplest thing that obeys that structure's laws. So the 'free monoid' for basic types is a type isomorphic to the list type.
ben_zen has quit [Quit: zonk]
csakatoku has quit [Ping timeout: 256 seconds]
<wmeyer>
levi: if you get something work I may have time to review now or later
* wmeyer
eagers to start playing with Indigo
manud has quit [Ping timeout: 260 seconds]
Kakadu has joined #ocaml
<levi>
The shape of a free monad depends on the shape of the functor (in the general sense, not the more restricted ML functor sense) it's built from.
<levi>
In the categorical sense, a functor maps both the objects and arrows of a category to another category such that structure is preserved. List can also be a functor in this sense; it maps type a to list of a, and it maps functions a->b to a list -> b list.
ttamttam has joined #ocaml
<levi>
Anyway, the free monad for the list functor is exactly the list monad, where return wraps an element in a list and bind maps the function over the list parameter and then concatenates the results into a single list.
Drup has quit [Quit: Leaving.]
<levi>
You could also define a tree type, and make it a functor by supplying a 'fmap' operation that applies a function uniformly over the tree. The free monad for your tree would then just be the monad instance that uses bind to call fmap on the argument and then merge the resulting trees by replacing the evaluated leaves with the new trees.
<levi>
If that makes any sense.
<wmeyer>
levi: what is your github id?
zpe has joined #ocaml
<levi>
wmeyer: pinealservo
<wmeyer>
interesting, you forked the project, but can't see anything on my dashboard
<levi>
whitequark: So, to answer your question, you don't get a list of thunks, you get an abstract syntax tree based on the structure of the data type your monad is parameterized with.
<wmeyer>
levi: thanks
<wmeyer>
levi: I am going to work now
bobry has joined #ocaml
<wmeyer>
levi: so see you a bit later
wmeyer has quit [Remote host closed the connection]
ygrek has joined #ocaml
<levi>
OK. I will probably be going to sleep soon.
zpe has quit [Ping timeout: 260 seconds]
cago has joined #ocaml
mika1 has joined #ocaml
<whitequark>
hm, the AST part went somewhat over my head
<whitequark>
I understand that conceptually it makes sense, but not how all parts combine together to product this effect
thomasga has joined #ocaml
manud has joined #ocaml
ocp has joined #ocaml
Simn has joined #ocaml
wwilly has joined #ocaml
<wwilly>
Bonjour :)
gnuvince has quit [Remote host closed the connection]
<rixed>
Mes hommages :)
rixed has quit [Quit: SSL here I am!]
zpe has joined #ocaml
Yoric has joined #ocaml
rixed has joined #ocaml
zpe has quit [Ping timeout: 245 seconds]
<ygrek>
regarding mli produced both by ocaml and ocamlopt - are those cmi the same?
<ygrek>
argh, read "regarding cmi produced ..."
<mrvn>
yes
Neros has joined #ocaml
chrisdotcode has quit [Ping timeout: 248 seconds]
Yoric has quit [Read error: Connection reset by peer]
chrisdotcode has joined #ocaml
<ygrek>
mrvn, and what is exactly the problem with parallel compilation?
<ygrek>
that somebody reads the file while it is written to?
<mrvn>
why do you ask me?
<ygrek>
cause you answered my previous question :)
<ygrek>
so I assume you have some clue on the topic?
<mrvn>
I might have a clue. I don't see a problem though.
tane has joined #ocaml
ggole_ has joined #ocaml
<ygrek>
they say some tool may read a partial cmi and error out when this happens
<ygrek>
the obvious fix is writing out cmi file atomically
<ygrek>
temp->sync->rename
<mrvn>
no.
Kakadu has quit []
<ygrek>
why?
<mrvn>
That would cause the other thing to build against an obsolete cmi file.
ggole has quit [Ping timeout: 245 seconds]
<ygrek>
the idea is that previous cmi was written out previously by ocamlc
<ygrek>
identical cmi that is
<mrvn>
Get the dependcies straight. If something needs the cmi then it needs to have a prerequisite on it and make will only build it after the cmi is done.
<ggole_>
Why the sync?
Xom has quit [Quit: ChatZilla 0.9.90.1 [Firefox 22.0/20130618035212]]
<mrvn>
If it is identical then you should replace it. causes unneccessary rebuilds.
<ygrek>
mrvn, yes, and that rules asks ocamlc to generate ocamlc
<mrvn>
shoudn't
<ygrek>
that's the problem I don't want to solve
zpe has joined #ocaml
<ygrek>
it is happening now with ocamlbuild I think
<mrvn>
I have no idea what your problem is. But if you are using a cmi before it is finished building then you are missinf a prerequisite.
<ygrek>
ggole_, that's a good habit if you don't want to lose data in case of machine crash
<ygrek>
on some fs
<ygrek>
mrvn, cmi is generated by ocamlc
<ygrek>
say on step1
<ygrek>
than in parallel the ocamlopt on the same ml is launched
<ggole_>
.cmi doesn't seem to warrant such measures
<ggole_>
Since you can just regenerate it
<ygrek>
and some other thing that depends on cmi in parallel
<ygrek>
ggole_, probably
<mrvn>
ygrek: then your build system is broken
<ggole_>
(And I'm told sync is unfortunately very expensive.)
<ygrek>
mrvn, so yo suggest to drop parallel opportunity in such case?
<ygrek>
ocamlbuild is not broken here
<ygrek>
it handles it
<mrvn>
there is no opportunity since you have a dependency on the result of the first.
<ygrek>
but pays missed parallelism opportunity for it
<mrvn>
it doesn't.
<ygrek>
a.ml -> a.cmi a.cmo; a.ml -> a.cmx a.cmi; and b.ml depends on b.cmi
<ygrek>
b.ml depends on a.cmi
<ygrek>
don't you see a parallelism opportunity
<ygrek>
?
<mrvn>
ygrek: sure. you can build a.cmo and a.cmx in parallel.
<ygrek>
and currently you can't, because cmi will overwrite each other
<ygrek>
(or at least I believe so)
<mrvn>
So let them overwrite
lopex has joined #ocaml
<mrvn>
unless ocamlc/opt does something stupid like truncating the file and overwriting it instead of unlink + create new one
sgnb` has quit [Remote host closed the connection]
IbnFirnas has joined #ocaml
<mrvn>
ygrek: It would be nice if ocamlc/opt had an option to create the cmi file and not to create the cmi file.
sgnb has joined #ocaml
<ygrek>
maybe that's not "typesafe" enough
<mrvn>
say you build in the following sequence: a.cmo (+a.cmi), b.cmo, a.cmx (+a.cmi) then b.cmo is out of date again and gets rebuild on the next run for no reason.
<ygrek>
just a wild guess why it is not done
<mrvn>
ygrek: it is done if you have a .mli file
<ygrek>
yeah, correct
<ygrek>
strange then
<mrvn>
It wasn't designed to build both bytecode and binary.
<ygrek>
hm, then probably ocamlbuild could use ocamlopt to build cmi when needed instead of ocamlc? deciding dynamically by the list of targets...
adrien_o1w has joined #ocaml
<mrvn>
ygrek: One thing I actualy want to do is use ocamlc -i to generate _build/a.mli. But only overwrite _build/a.mli if it changed.
<mrvn>
ygrek: it could do that if you only need one
talzeus_ has quit [Read error: Connection reset by peer]
<mrvn>
and by the way, why does -i cause .cmo/cmi not to be produced? That should be optional.
adrien_oww has quit [Ping timeout: 264 seconds]
<ygrek>
PR#4991 discusses the above observations
talzeus_ has joined #ocaml
<mrvn>
Re: opening the .cmi twice: the second open-for-reading is done to compute the MD5 digest of the data just written. OCaml's I/O channels don't support opening for reading and writing at the same time.
<ygrek>
why not compute md5 on string?
<mrvn>
ygrek: if you don't want to use the -intf-suffix then try ocamlc -o foo_temp.cmo ... && { cmp -q foo_temp.cmi foo.cmi || mv foo_temp.cmi foo.cmi }
<ygrek>
Re: atomic file rename: it's unclear this can be done under Windows
<mrvn>
screw windows
<mrvn>
ygrek: The problem with -intf-suffix is that you then need to use ocamlc even when you don't need the .cmo. Or you have to build different depends for .cmo, .cmx and .cmo+.cmx builds.
<mrvn>
ygrek: note: The atomicity of rename makes no difference because of the cmp. The .cmi only gets replaced if it changed and it can only change if the source changed and then anything needing the cmi will be blocked by the dependencies and can't run in parallel to the mv.
<ygrek>
I don't actually see the problem with non-atomic rename on windows
<mrvn>
Without the cmp it is a problem because something could open the .cmi just inbetween the rm and rename.
<mrvn>
open() could fail
<ygrek>
iiuc it can be inconsistent only on errors, i.e. if something is badly broken, e.g. fs
<ygrek>
but not in between
<mrvn>
no. if rename is not atomic then it can randomly fail
<ggole_>
The windows solution to that is file locking afaik
zpe has joined #ocaml
adrien_o1w is now known as adrien_oww
<ygrek>
oh, I forgot about that, we cannot even delete the file while it is open
<ygrek>
so no way to overwrite it in parallel
<ygrek>
crap
<mrvn>
ahh, the fun of windows. I go back to: screw windows
<mrvn>
if $(WINDOWS) .noprallel endif
<adrien_oww>
which language is that? :P
<mrvn>
adrien_oww: pseudo-make
<adrien_oww>
gnu make? ;-)
<ygrek>
mrvn, actually vista+ has atomic rename, but not winxp or win2k
<ygrek>
probably some conditional compilation can make it work fast on modern win and not break on old
<ygrek>
obv nobody really wants to jump onto this
mcclurmc has quit [Quit: Leaving.]
zpe has quit [Ping timeout: 256 seconds]
ollehar has joined #ocaml
zpe has joined #ocaml
<adrien_oww>
I don't think 2k is still supported by MS; XP will be dropped within a year
<adrien_oww>
do you still support linux kernel 2.0?
Kakadu has joined #ocaml
yacks has joined #ocaml
mcclurmc has joined #ocaml
<whitequark>
... some people actually still use 2.4
<adrien_oww>
yes, but 2.0?
weie has joined #ocaml
<adrien_oww>
and the question is whether your code actually supports 2.0, 2.2, 2.4
introom has quit [Remote host closed the connection]
q66 has joined #ocaml
beckerb_ has joined #ocaml
avsm has quit [Read error: Connection reset by peer]
ygrek has quit [Ping timeout: 268 seconds]
avsm has joined #ocaml
structuralist has joined #ocaml
dsheets has joined #ocaml
joostvb has quit [Ping timeout: 260 seconds]
rossberg__ has quit [Ping timeout: 260 seconds]
lifeng has joined #ocaml
joostvb has joined #ocaml
joostvb is now known as Guest21267
Kakadu has quit []
rossberg__ has joined #ocaml
ttamttam has quit [Quit: ttamttam]
avsm has quit [Quit: Leaving.]
gautamc has quit [Read error: Connection reset by peer]
gautamc has joined #ocaml
beckerb_ has quit [Ping timeout: 245 seconds]
djcoin has joined #ocaml
_andre has joined #ocaml
yacks has joined #ocaml
malo has joined #ocaml
manud has quit [Read error: Operation timed out]
tane has joined #ocaml
secret has joined #ocaml
<secret>
anyone on?
darkf_ has joined #ocaml
darkf has quit [Ping timeout: 264 seconds]
yezariaely has joined #ocaml
secret has quit [Quit: Page closed]
wwilly has quit [Quit: Leaving]
ygrek has joined #ocaml
beckerb_ has joined #ocaml
demonimin has joined #ocaml
secret has joined #ocaml
ygrek has quit [Ping timeout: 264 seconds]
wwilly has joined #ocaml
darkf_ is now known as darkf
csakatoku has joined #ocaml
csakatok_ has quit [Ping timeout: 264 seconds]
<yezariaely>
anyone has an idea of how to write the following recursive higher-kinded haskell type definition in Ocaml (probably using modules)? data Fix f= In (f (Fix f))
<yezariaely>
I have especially problems including the In data constructor
<pippijn>
now we have monads and lexically scoped resources
<pippijn>
(lexically scoped by with_dispose)
<orbitz>
I would structure it with a non-linear type layer and then a safe linear type layer above, so if someone does need to do something awkward they can
contempt has joined #ocaml
<pippijn>
ocaml+cool stuff
<pippijn>
would be.. really cool :)
<pippijn>
ocaml is getting nicer already
Qrntz_ is now known as Qrntz
Qrntz has quit [Changing host]
Qrntz has joined #ocaml
<wmeyer>
pippijn: I love OCaml
<orbitz>
Ocaml is the best language I know
<orbitz>
and i don't even know it that well
<wmeyer>
when will you come to cambridge pippijn ?
<jdoles>
Does OCaml have any library in which it excels?
<wmeyer>
the best from the most practical ones, it's well balanced
<wmeyer>
but Coq is probably most powerful general purpose language
<wmeyer>
pippijn: I insist on beer
<orbitz>
jdoles: can you give an example of what you mean?
<jdoles>
orbitz: AFAIK, pretty much all interesting data structures are implemented in C or C++ first.
<pippijn>
wmeyer: it's hard to write programs in coq :\
<pippijn>
I just keep running into walls
<pippijn>
it's like making a build system with omake
<wmeyer>
pippijn: it's hard but feels powerful
<pippijn>
wmeyer: exactly like omake
<jdoles>
orbitz: additionally they are often more efficient that way too.
<orbitz>
jdoles: I don't think that is true. Most interesting data strucutres were probably implemented in FORTRAN or LISP first
<Drup>
jdoles: try do to immutable data structure in C, it's gonna be fun :3
<jdoles>
orbitz: I have never read a paper in which that was the case.
<pippijn>
the lack of projects made with coq and the lack of documentation about coq makes it more difficult
<jdoles>
Drup: they did that... in the 1970s.
<pippijn>
ocaml has *lots*
<pippijn>
of both
<Drup>
jdoles: yes, and it's still a pain
osa1 has joined #ocaml
<orbitz>
jdoles: I've read many papers where the data structure is not implemented in C first. For example: zippers, finger trees, ...
<pippijn>
finger trees..
<jdoles>
orbitz: zippers were invented in C first.
<jdoles>
orbitz: it's just that whoever wrote first about zippers was rather ignorant about data structures.
<jdoles>
As for finger trees, they don't do anything which wasn't possible before they were created.
<orbitz>
but you just told me they were implemented in c first
<jdoles>
orbitz: zippers are just a new name for an old technique.
<orbitz>
jdoles: citation plz
<jdoles>
orbitz: if you would read that paper, you would see that the author cites those.
<orbitz>
I have read the paper
<jdoles>
orbitz: perhaps you need to read it again then.
<orbitz>
Anyways, to answer your question, Ocaml is decent ast functional data structures and encoding various constraints in types which is useful for many APIs
<orbitz>
jdoles: proabbly, it was last year
<jdoles>
I will just say it again: NOBODY IN THE FUNCTIONAL PROGRAMMING "COMMUNITY" HAS EVER DONE ANYTHING USEFUL FOR COMPUTER SCIENCE.
<Drup>
that was an interesting conversation at least
<mrvn>
jdoles: yeah, lambda calculus is totaly unheard of in computer since. keep of dreaming.
<orbitz>
what does '"community"' mean here?
<orbitz>
are you making a distrinction between something else realted to fp?
<mrvn>
s/since/science/
<jdoles>
mrvn: lambda calculus is just another formal model for computation, and a rather simplistic one at that.
<jdoles>
There are many more such models.
<orbitz>
And?
wmeyer has quit [Remote host closed the connection]
wmeyer has joined #ocaml
<Drup>
guys, why do you keeping discussing with him ? :/
<pippijn>
jdoles: do you advertise tup?
<jdoles>
And, it means that something invented before there even were electronic computers has no relationship with people related to Haskell/OCaml/Agda/...
<wmeyer>
hi Drup !
<orbitz>
I'm not sure what point you're making.
<jdoles>
pippijn: I think tup is a good idea, sure.
<Drup>
wmeyer: hi :3
<jdoles>
pippijn: why?
<pippijn>
ok
<orbitz>
Various contributions have been made via ocaml, haskell, agda
<mrvn>
orbitz: I think he is just trolling. Lets stop feeding him
<Drup>
wmeyer: are you in a gadt mood ?
<orbitz>
ok
tane has quit [Quit: Verlassend]
<pippijn>
nothing
<jdoles>
The calculus behind Coq could be said to have been a contribution of some sort.
<wmeyer>
Drup: actually i am sleepy, made 10 miles today, and did a 2h training
<wmeyer>
but i am going to start once i got up
<jdoles>
But I don't know whether that has been a completely new work, not derived from something else which already existed in logic.
<jdoles>
Implementing Coq however, is just engineering, not computer science.