buluca has quit [Read error: 113 (No route to host)]
ser_ has joined #ocaml
ser_ has quit [Read error: 104 (Connection reset by peer)]
ser_ has joined #ocaml
nuncanada_ has quit ["Leaving"]
ser_ has quit [Read error: 113 (No route to host)]
ser_ has joined #ocaml
ser__ has joined #ocaml
ser_ has quit [Read error: 113 (No route to host)]
ser__ has quit [Read error: 104 (Connection reset by peer)]
jlouis has joined #ocaml
jlouis_ has quit [Read error: 110 (Connection timed out)]
<fbvortex>
So I've put a module definition (struct) in a .ml file, then compiled it using ocamlc . In the toplevel, if I use #load "mymodule.cmo" , then when I try to access MyModule.x I get an error that MyModule.x is unbound; if I directly paste the code in mymodule.ml into the toplevel, then all of the module seems to be accessible. Why are these two methods giving different results? What do I need to do with mymodule.ml so that when I load its cmo fil
<Jeff_123>
.ml files automatically get a module
<Jeff_123>
so somefile.ml, compiled somefile.cma (or .cmo), and suppose somefunction is in somefile.ml, you call somefunction by doing
<Jeff_123>
#load "somefile.cmo";;
<Jeff_123>
Somefile.somefunction
<Jeff_123>
so the way you have it working now, it'll probably work if you do
<Jeff_123>
Mymodule.MyModule.x
jlouis_ has joined #ocaml
seafood_ has joined #ocaml
<fbvortex>
Jeff_123: fantastic. Thanks, that worked. What happens if I have mymodule2.cmo that depends on mymodule1.cmo, and I load them manually into the toplevel using two #load directives? Will the code in mymodule2 that has the form MyModule1.member work as-is?
<fbvortex>
Or will the additional level of nesting need to be accounted for?
<Jeff_123>
it will work as-is
<Jeff_123>
If you haven't already, you should get rid of the redundant module X = struct end that you wrapped around your source.
<Jeff_123>
it will save you some keyboard action in the long run
jlouis has quit [Connection timed out]
<fbvortex>
What is the recommended style when writing unit tests for functions that are internal to a module and not exposed in the signature? Should the tests themselves be part of the module with an exposed interface? Is there a way to access a module's structure and bypass its signature?
<tsuyoshi>
I don't think there's a way to bypass the signature
<fbvortex>
I figured as much, but what then is the recommended way to do the kind of thing I'm trying to do? It makes sense to unit test "private" code within modules, no?
ita has quit ["Hasta luego!"]
<Smerdyakov>
fbvortex, yes
dbueno has joined #ocaml
<tsuyoshi>
you could temporarily remove the signature, I guess
<fbvortex>
Smerdyakov: do you have any recommendations/suggestions on how such tests ought to be implemented?
<Smerdyakov>
fbvortex, the same way you would normally; just inside the module.
<JohnnyL>
Smerdyakov, hey dude. what did we talk about last time?
<JohnnyL>
oh yeah
<JohnnyL>
thats right
<JohnnyL>
you called me Captain Kirk?!
<JohnnyL>
haha
<JohnnyL>
SPOCK!
<Smerdyakov>
JohnnyL, we tend less to have conversations than tragedies.
<Smerdyakov>
JohnnyL, and I have no idea what you are talking about now.
<Smerdyakov>
JohnnyL, oh, now I remember. That was one line, not really a subject of conversation.
Hadaka has quit [Read error: 145 (Connection timed out)]
mordaunt has joined #ocaml
Naked has joined #ocaml
Naked is now known as Hadaka
wy has joined #ocaml
<wy>
hello!
<FreshCat>
lo
CRathman__ has joined #ocaml
CRathman__ is now known as CRathman
CRathman has quit [Remote closed the connection]
mrsolo has quit ["This computer has gone to sleep"]
wy has quit ["Leaving"]
spawn has joined #ocaml
spawn has quit [Client Quit]
mrsolo has joined #ocaml
wy has joined #ocaml
<wy>
hello
<Jeff_123>
hi wy
<wy>
Hi Jeff
<wy>
I'm trying to convert all my programs written in Java before to Ocaml, or for some compromise, OCaml styled Java
<Jeff_123>
That sounds like it could be fun.
<wy>
For some practical reason, I'm trying to write FP styled Java right now, but somehow I found as if there are some fundamental difference and that would prevent me to do so.
<Jeff_123>
Java doesn't do partial function application afaik.
<wy>
Uhh... That's absolutely true
<wy>
The problem I'm encountering is from the object oriented design
<Jeff_123>
hm
<wy>
It's a render program for graphics. I have three kinds of "Records": IntersectionRecord, LuminaireSamplingRecord, MediumSamplingRecord
<wy>
Previously, those types are not regarded as "similar", so my code is messy with lots of duplicates
<wy>
But I realized that they are just variants of something could be called "InteractionRecord"
<wy>
Sorry, I'll stop here if nobody is interested
<Jeff_123>
well I'm interested but I'm not sure I can help you
<wy>
Jeff_123: Are you familar with OCaml?
<Jeff_123>
yes, and OO programming
<wy>
Java? So I guess you can.
<wy>
Just a small thing here
FreshCat has quit [Read error: 110 (Connection timed out)]
<wy>
So in order to make them variants, I defined the abstract class InteractionRecord, and let the three extends InteractionRecord.
<Jeff_123>
Well I mean, it sounds like you already have an idea what you want to do... make 1 super class to reduce duplicate code?
<Jeff_123>
ok sounds good
<wy>
The problem now is that there is a method inside each of those three, called "set", that assign objects with the same class.
<Jeff_123>
hm, I'm not sure I see what the problem is still
<Jeff_123>
these methods create new objects or ?
<wy>
Because they have "set" method, I just define an abstract method in my abstract class
seafood has quit [Read error: 113 (No route to host)]
<Jeff_123>
is there a type conflict or something like that?
<wy>
So the abstact one has this signature: abstract void set(InteractionRecord inRecord)
seafood has joined #ocaml
<wy>
After I defined this, I got errors from those three classes. That says I have type conflict with the abstract class I'm supposed to impliment. Because the abstract class has "InteractionRecord" as argument, but the three classes have their own class name as argument type
<Jeff_123>
oh hm
ikaros has joined #ocaml
<wy>
Do I just coerce?
<wy>
I found I'm adding "instance of" tests and coercions into the three classes. That's really ugly
<Jeff_123>
Hm, I find myself thinking in c++ where set's argument would be defined by a template
<Jeff_123>
but java hm
<wy>
If it were OCaml, I could just define those functions, and the functions will all have type "InteractionRecord->unit" or somehting. Right?
<Jeff_123>
well why inherit set? Why not just add it to the child classes but leave it out of the parent class?
<wy>
That's a good question. Maybe the whole design should be revised before I do any modification.
<wy>
I'm thinking if there should be "set" at all because that sounds totally impirical
<wy>
wrong word: imperative
<Jeff_123>
it returns void right?
<Jeff_123>
If my understanding is right, set both creates an object somewhere and returns void... that wouldn't be in the functional style. Not that it's wrong of course.
<Jeff_123>
just you said you wanted to be ocaml-ly
<wy>
right. That's not ocaml-ly
<wy>
I just tried to get rid of the set
<wy>
And I found that I must put all the fields of the variants into the abstract class
<Jeff_123>
ah that makes sense
<wy>
Do you think a "set" method for the conversion of classes weird in a ML sense?
<wy>
Really? You think I should put all the fields into the abstract class?
<Jeff_123>
hehe I dunno
<wy>
That's a lot of typing, and weird... ;-)
<Jeff_123>
for type conversion in caml you have to do it explicitly
<Jeff_123>
eg int_of_string
<wy>
That make sense... Maybe I should do so
Jeff_123 has quit [Read error: 104 (Connection reset by peer)]
Jeff_123 has joined #ocaml
<Jeff_123>
ok i'm back... I shouldn't've been playing with my powerbook's battery release switch
<Jeff_123>
but ya, if you make all your type conversions explicit it can help make any problems explicit
<Jeff_123>
...I guess. I dunno how it would work out in java.
<wy>
I could just change that function to something else
<wy>
return a new object of a different type
<wy>
I found the only use of this "set" method
<wy>
That's only because LuminaireSamplingRecord has some method that IntersectionRecord doesn't
<wy>
Weird?
<Jeff_123>
I dunno :\
<wy>
You converted your type to something else just because they have different names
<Jeff_123>
haha
<Jeff_123>
function Something s -> SomethingElse s. There's times you want to do something like that.
<Jeff_123>
but if they're different only in name, ya why bother
<wy>
Still weird .. in a philosophical sense?
<Jeff_123>
I guess i'd have to see it.
<wy>
That's a pretty nice program though lots of duplicated code ;-)
<wy>
I guess I would rewrite this thing into OCaml at some later time
<Jeff_123>
how big is it?
<wy>
Do you think OCaml would have much better performance?
<wy>
than Java
<Jeff_123>
it'd load faster if it were compiled to native code
<Jeff_123>
but ya ocaml is often faster than java
<Jeff_123>
memory usage is way lower
<wy>
So there is no reason I don't use it uh. I could have changed the whole field
<Jeff_123>
hehe
<wy>
graphics ;-)
<Jeff_123>
well, you wont have access to java's huge standard library
<Jeff_123>
are you doing 2d or 3d graphics?
<wy>
That's could be a problem. I'm doing 3d
<Jeff_123>
1 sec
<wy>
But my program is just a render
<wy>
That requires lots of CPUs running for days ;-)
<Jeff_123>
there are already some raytracers written in ocaml on the web
<wy>
good. Maybe I should learn from them
<Jeff_123>
1 sec, i'm tryign to link you one but the webpage is loading slowish for me
<Jeff_123>
ocaml is there twice, once for native code once for bytecode
seafood has quit [Read error: 110 (Connection timed out)]
seafood_ has quit []
seafood has joined #ocaml
<wy>
Thanks
<wy>
The red entries are strange. Haskell got many, as if not many people write correct haskell code
<Jeff_123>
eh, it's fast for some things, slow for others, same as anythign else
<wy>
But for overall performance, Haskell is slower
<wy>
I'm not comparing gcc and ocaml carefully
<wy>
not/now
<flux>
you might also want to check out the actual code, it might not be typical or even elegant :)
<Jeff_123>
the only thing I haven't been able to get ocaml to do quickly is multiply huge integers.
<Jeff_123>
like millions of digits in just a couple seconds
<Jeff_123>
doesn't look like java can do it either
<Jeff_123>
ok only c and c++ can do it from waht I can see
__suri has quit []
<flux>
isn't that mostly a library issue?
<flux>
have you checked out the other big integer libraries?
<flux>
I recally seeing name 'numerix' somewhere
<Jeff_123>
caml's isn't fast enough
<Jeff_123>
I mean native ocaml code can't do it. with an external library, sure
kelaouchi has quit ["leaving"]
<flux>
I thought you were using a library in C too
<flux>
you're doing it with your own code?
<wy>
Is the C interface convenient to use?
<Jeff_123>
hm, I dunno. the ocaml manual shows how to do it though
<flux>
I think it is, when the interface is clean.. at times there might be trouble.
<wy>
C is most good at this kind of thing
<Jeff_123>
there are bindings to quite a few popular llibraries
<flux>
but it's mostly manual routine work doing the bindings. there are some tools to help with that, though.
<wy>
cool
<wy>
I wonder why isn't there any cool GUIs around that can be used
<flux>
usedd for what?
<flux>
for making the conversion?
<wy>
I mean write GUI programs in OCaml
<Jeff_123>
sure
<flux>
gtk and tk aren't sufficient for your needs?
<Jeff_123>
there are bindings to Tk and GTK
<wy>
Because I might want to write something like the Adobe tools
<Jeff_123>
also you can use opengl
Snark has joined #ocaml
ttamttam has joined #ocaml
<wy>
Tk and GTK are not nice looking enough. Don't you think? Coq is in tk I guess
<wy>
I hope it's always possible to wrap something I need
<Jeff_123>
possible, not always convenient or easy
<Jeff_123>
it's starting to sound like you should just do your work in c or c++. you want speed? access to lots of libraries?
<wy>
No c or C++. I care about elegancy too much ;-)
<wy>
OCaml has enough speed I guess
<Jeff_123>
heh it better, cause if you want more speed you have limited options
<wy>
If it's easier to be parallelised... That would be greater than C
<Jeff_123>
erlang, stackless python, jocaml
<wy>
Thanks a lot for the pointers
<Jeff_123>
you're welcome. hope I helped a bit
<wy>
I guess I'll spend sometime learning those things before my actually implementation
<Jeff_123>
afaik erlang is the most well established of the 3
<Jeff_123>
but i'm sure they all have their pros and cons
<Jeff_123>
have fun :)
<wy>
I hope one of them would have some environment like eclipse and lots of libraries
<wy>
What's erlang about?
<Jeff_123>
try its wikipedia article
<Jeff_123>
I just know its specialty is parallel code.
kelaouchi has joined #ocaml
Jeff_123 has quit ["Quit"]
<wy>
Looks like Lisp
<wy>
No algebriac types...
<wy>
I guess I don't need it for this thing. I don't really have lots of parallel processes.
<wy>
alright I guess I could settle down with OCaml for a while
<wy>
Thanks for so much information. I must go sleep now. Good night!
wy has quit ["Leaving"]
Tetsuo has joined #ocaml
david_koontz has quit []
bluestorm has joined #ocaml
david_koontz has joined #ocaml
filp has joined #ocaml
Jeff_123 has joined #ocaml
m3ga has joined #ocaml
m3ga has quit ["disappearing into the sunset"]
cpst has joined #ocaml
Jeff_123 has quit [Read error: 110 (Connection timed out)]
rayno has quit [Read error: 110 (Connection timed out)]
Yoric[DT] has joined #ocaml
marmottine has joined #ocaml
<Yoric[DT]>
hi
<flux>
hello
david_koontz has quit []
hkBst has joined #ocaml
zmdkrbou has quit [Read error: 104 (Connection reset by peer)]
zmdkrbou has joined #ocaml
ttamttam has left #ocaml []
gaja has joined #ocaml
mrsolo has quit ["This computer has gone to sleep"]
gaconnet has joined #ocaml
<cpst>
is there an ocamldefun for 3.10 anywhere?
<flux>
wish there was
<flux>
hm, s/was/were/, right?
<Smerdyakov>
flux, I think that's right.
seafood has quit []
|Catch22| has quit []
yminsky has joined #ocaml
seafood has joined #ocaml
seafood has quit []
seafood has joined #ocaml
buluca has joined #ocaml
sebas_ has joined #ocaml
ikaros has quit [Remote closed the connection]
ita has joined #ocaml
sebas_ has quit ["Leaving"]
__suri has joined #ocaml
rayno has joined #ocaml
kirkt has joined #ocaml
<kirkt>
is there any place a man new to functional programming (but not academic scheme, or lisp) can go to see all the glory of it?
<kirkt>
(except hell)
<Smerdyakov>
I don't understand the question.
<Yoric[DT]>
I believe he's looking for a tutorial :)
<kirkt>
yea, more like a showcase tutorial
<kirkt>
or a cookbook
<Smerdyakov>
OCaml is sufficiently un-crappy that it doesn't need a cookbook.
<Smerdyakov>
Common patterns can be represented explicitly as libraries.
<Yoric[DT]>
Or if they can't, by Camlp4 preprocessors.
<kirkt>
well, last night i had an enlightenment. i discovered why all functional language people are so smug about it.
<Smerdyakov>
Yoric[DT], those cases are rare enough that we don't need a cookbook.
<Yoric[DT]>
fair enough
<Yoric[DT]>
kirkt: welcome to the smug side of the Force.
<kirkt>
to make a long story short.. i now see how declarative is alot better than imperative. and i NEED to know more, i'm truly possesed
<kirkt>
the funny thing is, that during an entire course in scheme, i never saw the true meaning.
<Smerdyakov>
Read the tutorial in the OCaml manual and then try a mix of working on a real project and looking at the OCaml libraries out there.
<kirkt>
i have to admit i want to learn OCaml to get closer to F#.
<JohnnyL>
kirkt, you must have come from #lisp.
<JohnnyL>
kirkt, sounds like you want a turid love affair.
* JohnnyL
snickers.
<kirkt>
i never laid hands on lisp
<kirkt>
i've had experience with the younger scheme though.
<JohnnyL>
Smerdyakov doesn't understand my understanding of his understanding.
<JohnnyL>
kirkt, i have found that lisp and ocaml don't fall far from the same tree.
<Smerdyakov>
kirkt, is my answer satisfactory?
<kirkt>
Smerdyakov: yes, thanks.
FreshCat has joined #ocaml
<FreshCat>
has anyone tried the OS X binary installer on Leopard?
<FreshCat>
hm, seems funcional
<FreshCat>
cool
yminsky has quit []
<kirkt>
is ocaml close to haskell ?
<Smerdyakov>
Yes.
<bluestorm>
depends on how much close you want
<kirkt>
i just mean syntactically
<bluestorm>
hm
<bluestorm>
syntactially it is not so close
<JohnnyL>
Smerdyakov, what are some defining algorithms that make functional languages different from imperative ones?
<bluestorm>
you can have haskell code looking like ML, but the usual way is not really close
<Smerdyakov>
JohnnyL, I don't understand.
<bluestorm>
although with a little training i can read Haskell rather easily, whereas i never use it
<JohnnyL>
Smerdyakov, like order of operation, etc.
<bluestorm>
"defining algorithms" ?
* JohnnyL
thinks imperatively.
<JohnnyL>
not functionally.
<Smerdyakov>
JohnnyL, sorry, I still don't understand.
<JohnnyL>
Smerdyakov, no problem. it wasen't important. carry on.
<bluestorm>
JohnnyL: the absence of for/while loops ?
<bluestorm>
hm
<bluestorm>
s/absence/lack/
<bluestorm>
when you think functonal, you avoid loops and mutable variables
<bluestorm>
every other algorithme you can come with wich does not use loops or mutable variables is likely to be "functional"
<bluestorm>
-e
<Smerdyakov>
The definition of "functional language" involves not only freedom from side effects, but also closures.
<bluestorm>
(of course, when using OCaml you'll sometimes want to use references and loops, so this is only a general rule)
<bluestorm>
Smerdyakov: i do not know how to advise people to use closure
<Smerdyakov>
I didn't see any context of advising anyone to do anything in this conversation.
<bluestorm>
from my own experience, it just becomes natural when you have tried to avoid side effects for some time
<JohnnyL>
bluestorm, what I'm saying is, how does functional look from the compiler. I mean there have to be loops in the code in order for functional land to work.
<JohnnyL>
bluestorm, how are they not mutable?
<Smerdyakov>
JohnnyL, maybe you want to read Chapter 15 of "Modern Compiler Implementation in ML."
<Smerdyakov>
JohnnyL, you're serious? You don't understand how OCaml variables are immutable?
<JohnnyL>
Smerdyakov, I haven't given it much though. let x in y =
<JohnnyL>
[{blah]}
<Smerdyakov>
What the hell is that supposed to be?
<Smerdyakov>
Allowed in Scheme (though I may be making a syntax mistake): (let ((x 1)) (setq x 2))
<Smerdyakov>
Not allowed in OCaml: let x = 1 in x := 2
<Smerdyakov>
Get it?
kirkt has left #ocaml []
<JohnnyL>
Smerdyakov, yeah easy. thanks.
<JohnnyL>
i like thatr.
<JohnnyL>
makes you use more variables.
<Smerdyakov>
I have to say, though, if you're hanging around here and participating in conversations when your knowledge of OCaml is so minimal that you didn't know what variables are, then you should consider whether you ought to be on your way.
<JohnnyL>
Smerdyakov, how would you implement your own funcational language if you were to build it, from say lex, yacc?
<flux>
however, you can do let x = 1 in let x = 2 in .., which could be confusing to someone familiar with out imperative mechanisms
<JohnnyL>
Smerdyakov, that last comment of yours had nothing to do with Ocaml, and much to do with how little you know of how little I know.
bebui has quit [Read error: 110 (Connection timed out)]
<flux>
but it doesn't really change anything. for example, if you have a function defined between those two bindings, if you call it, it will behave based on the binding x at its definition point
Jeff_123 has joined #ocaml
mrsolo has joined #ocaml
<JohnnyL>
Smerdyakov, anyone can view another person's code. but only few can be taught about it and learn.
<Smerdyakov>
Compilation of functional languages is not a simple enough topic with which to do the Plato-on-the-steps thing on IRC.
<JohnnyL>
thats why I think I'll just make my language imperative.
<Smerdyakov>
Good choice. You don't seem smart enough to do it right. ;)
<JohnnyL>
thanks
<JohnnyL>
alot
<bluestorm>
:D
<JohnnyL>
bluestorm, Smerdyakov likes a margin between him and the rest of his channel users.
<JohnnyL>
Is it lonely at the top Smerdyakov ?
<Smerdyakov>
Just between me and channel users as bothersome as you, JohnnyL.
<bluestorm>
Smerdyakov has weird relational ways
<bluestorm>
i personally don't care
<JohnnyL>
bluestorm, yeah, it's like ego trip central.
<bluestorm>
JohnnyL: if you're interested into implementation of functionnal languages, you can find some ressources on the web
<Smerdyakov>
I already pointed him to a book chapter with a quick summary.
<JohnnyL>
bluestorm, ok
<bluestorm>
this afternoon i just found a Simon Peyton Jones paper/book on that topic
<bluestorm>
Smerdyakov: is it the Appel book ?
<bluestorm>
i have to try to read it some day
<Smerdyakov>
bluestorm, yes.
<Smerdyakov>
He could also read the source of my certified functional language compiler in Coq. *cackle*
<JohnnyL>
bluestorm, how about just looking at the lisp model? or is that too imperfect?
FreshCat has quit ["GURU MEDITATION ERROR"]
<bluestorm>
i'm not sure "lisp" in the wide qualifies as a "functional programming language"
<Smerdyakov>
And what is "the lisp model"?
Amorphous has quit ["shutdown"]
yminsky has joined #ocaml
<bluestorm>
hm, i'm currently (re)writing a wanna-be wikipedia article about OCaml
bebui has joined #ocaml
<bluestorm>
what would you write in the "Criticism" section ?
<JohnnyL>
bluestorm, ok, thanks.
marmottine has quit [Excess Flood]
<bluestorm>
for now i have "- not so active community" and "- no ad-hoc polymorphism"
<JohnnyL>
bluestorm, it does seem very imperative to me. (i'm not sure if progn actually does anything but serve as a label).
marmottine has joined #ocaml
<JohnnyL>
Smerdyakov, For some reason everytime you talk, you look more and more like a black hole to me.
<bluestorm>
JohnnyL: you could consider a 'pure' (from a functional programming point of view) subset of lisp
<hcarty>
bluestorm: As a specific, the + vs +. is a common complaint
<bluestorm>
hcarty: "-no ad-hoc polymorphism" seems the right place to say that
<hcarty>
bluestorm: True, but to a non-CS person that's quite opaque :-)
<bluestorm>
yes
<bluestorm>
i would expand a little bit, of course
<Smerdyakov>
bluestorm, have you seen my OCaml/SML comparison? Plenty of criticisms there.
<bluestorm>
i've just re-read it
<bluestorm>
with a quick glance i didn't found really general-purpose criticism
ttamttam has joined #ocaml
<bluestorm>
i'm not sure the "equality polymorphism mess" will make it in a encyclopedic article
<bluestorm>
hm
<bluestorm>
i could use the "only one implementation" thing, though
<bluestorm>
and yes, the "formal design" thing too. Would be a good way to link to the "OCaml light" thing, actually :p
<Smerdyakov>
You know as well as I do that they skip the interesting features in that.
<bluestorm>
hm ?
<bluestorm>
ah
<bluestorm>
you're talking about Ocaml Light
<hcarty>
You could list/link the ocamljava project as another implementation
<bluestorm>
of course, it's "an attempt of formal definition..." or something like that
<bluestorm>
hcarty: right
<bluestorm>
and i saw something like "Ocaml -> JS" thing recently
<bluestorm>
but it's still rather alpha, could not be compared to the numerous solid SML implementations out there
<Smerdyakov>
hcarty, my page certainly has it.
<Smerdyakov>
hcarty, but do they yet cover all features of the regular ocaml compiler?
<Smerdyakov>
hcarty, if not, then you can't really call it another implementation, since 'ocamlc' defines the language.
<hcarty>
Smerdyakov: According to the website it does
<bluestorm>
" ocamljava is even able to build a working ocamlc.jar file that is the Java-compiled version of the ocamlc compiler. "
<hcarty>
But I haven't gone through the process of compiling and testing it
<bluestorm>
btw
<bluestorm>
do you know wich ones of the "ocaml-derived language" project are still alive now ?
<bluestorm>
the en-wp article details MetaOCaml only
<bluestorm>
i think JoCaml would deserve some space
<bluestorm>
but i'm not sure avec GCaml state for example
<Smerdyakov>
No, I don't know.
<hcarty>
Is metaocaml still alive?
<hcarty>
I hope JoCaml sticks around as it seems quite useful
<flux>
I've read comments that metaocaml isn't very alive
<flux>
does metaocaml bring more than just performance benefits? of course, they can be important, too..
<bluestorm>
metaOcaml is not very active
<bluestorm>
but they got some noise with Concoqtion not so long ago
<flux>
concoqtion sounds so interesting that makes me really want to find the time to study it :)
<bluestorm>
(2007, May)
<flux>
(+it)
<flux>
(it=coq)
yminsky has quit []
<hcarty>
What are "private abbreviation types"? They are listed in the OCaml CVS changelog as a new feature
<bluestorm>
there was something in the mailing-list about it recently