Smerdyakov has quit [Read error: 110 (Connection timed out)]
<CoolPops>
What exactly does 'Some' mean?
wegzze has joined #ocaml
kinners has joined #ocaml
<CoolPops>
Can anyone explain what Some is to me? I'm reading the docs, have read and made several of my own types for learning but still no idea how to map: # row;;
<CoolPops>
- : string option array option = Some [|Some "1"; Some "John Doe"|]
<pango_>
CoolPops: Some is one of the two constructors of the option type... The other is None
vezenchio has quit [Read error: 110 (Connection timed out)]
<CoolPops>
pango_: I have just went through the manual (used grep even) about Some w/no luck finding it. Do you know where it is or a page that may help me understand what it is and how it works?
Smerdy is now known as Smerdyakov
<pango_>
# match row with
<pango_>
| None -> ()
<pango_>
| Some a -> match a.(0) with
<pango_>
| None -> ()
<pango_>
| Some s -> Printf.printf "%s\n" s ;;
<pango_>
1
<pango_>
an option either exist, or it doesn't; That's two separate cases. Either it doesn't exist (None), or it exists and has some value (Some s)
<pango_>
It's just a specific case of sum types
<kinners>
CoolPops: it is just a simple sum type, so learn about those
<Smerdyakov>
CoolPops, you should need no special documentation on option.
<Smerdyakov>
CoolPops, the one-line definition of 'a option that we discussed earlier should be all you need.
* CoolPops
is looking back thru the chat log.
<CoolPops>
So option simply means it can be Some or None ?
<pango_>
CoolPops: type 'a option = None | Some 'a for any type 'a
<pango_>
Some of 'a even
<CoolPops>
ok. I think I am understanding a bit clearer. I've been a C/Java/PHP programmer for 10 years now, never touching anything like OCaml. It's quite a change with many new things.
<CoolPops>
but to get at the data, you must do the match? Everything was so simple, clean, easy until this part.
<pango_>
CoolPops: yes... to access an option, you must use match, that does both the test and the deconstruction at the same time
<CoolPops>
# let db = quick_connect ~database:"test";;
<CoolPops>
# let res = exec db "SELECT * FROM users";;
<CoolPops>
# let row = fetch res;;
<pango_>
CoolPops: so you cannot try to "dereference" None, as you can with other languages with NULL...
<pango_>
CoolPops: personally I think match is a very beautiful feature
<pango_>
CoolPops: that's the main one I remembered from my meet with ML languages at uni
<CoolPops>
I probably just need to understand it a bit better.
<CoolPops>
I'll continue to read.
<Smerdyakov>
CoolPops, you should not be asking us this.
<Smerdyakov>
CoolPops, you should read about the 'type' definition, like I suggested before.
<CoolPops>
Smerdyakov: sorry. I did read about the type option and no where that I can find does it mention some or option.
<CoolPops>
Smerdyakov: I have been reading sequentially as well and am far past type... with doing the examples, exploring and doing my own things as well with the things I have learned.
<Smerdyakov>
CoolPops, that's right. It is good that it doesn't mention Some or option.
<Smerdyakov>
CoolPops, the _definition_itself_ gives you _all_the_information_you_need_.
<Smerdyakov>
CoolPops, the definition I mean is: type 'a option = None | Some 'a
<Smerdyakov>
CoolPops, I'm confused as to why you expected to see option mentioned. Would you be stuck as to how to use the String class in Java because the section of a tutorial that introduces the 'class' keyword doesn't mention 'String' explicitly?
<CoolPops>
Smerdyakov: but w/o ever seeing the word Some before it's confusing. String is easy to understand, it's used throughout almost all languages. Some is not.
<Riastradh>
CoolPops, so substitute any other random class for 'String' in Smerdyakov's example.
<Riastradh>
The important thing isn't Some or None; the important thing is the meaning of 'type 'a option = Some of 'a | None', which you seem to fail to understand.
<CoolPops>
If you know something is a class (by looking at the API docs) then it's easy.
<pango_>
# type 'a maybe = No | Yes of 'a ;;
<Riastradh>
The type declaration should be all you need.
<Smerdyakov>
CoolPops, the interface of a Java class gives you all the information you need on how to interact with it, syntactically.
<CoolPops>
I understand now... type 'a option = None | Some 'a means that it can be either Nothing or can contain Something, correct?
<Smerdyakov>
CoolPops, a 'type' definition in ML gives you an analogous amount of information.
* CoolPops
is sorry that Ocaml is confusing to him at first sight.
<Smerdyakov>
CoolPops, do you feel that is not clear from the tutorial? How does it explain the use of 'type' with '|'?
<CoolPops>
type my_usr_status = Unauthorized | Active | Super; ... easy. Or, Or, Or.
<Smerdyakov>
CoolPops, do you feel it's not clear from the tutorial?
<Smerdyakov>
CoolPops, you see, I'm having serious doubts that you actually bothered to read it carefully. ;)
<CoolPops>
that is, because it is using Int, Float, Error ... all are which types I can lookup and see what they are.
<CoolPops>
Smerdyakov: I know.
<pango_>
CoolPops: it's more like union types, but *safe* (I wonder why so many languages are still lacking something so evident as sum types)
<Smerdyakov>
CoolPops, I hope it's clear that I don't plan to help you further on this unless you demonstrate that the tutorial you've chosen has deficient coverage of the issue.
<CoolPops>
Smerdyakov: it also does not explain the keyword option. so I was not use to seeing that. Even when you type: type me = Good_Reader | Bad_Reader;; it does not say type me = option Good_Reader | Bad_Reader;; it omits the option. I don't know if that's something special or not, and I can't find if it's special or not because it mentions it nowhere.
<Smerdyakov>
CoolPops, 'option' is not a keyword.
<CoolPops>
Smerdyakov: yes, and that is fine. I don't expect someone to walk me through what they can read.
<Smerdyakov>
CoolPops, 'option' is a name like any other.
<CoolPops>
Smerdyakov: bad word choice... because I did look at the keyword index trying to find it as well.
<Smerdyakov>
CoolPops, "type me = option Good_Reader | Bad_Reader;;" would yield you a syntax error.
<CoolPops>
Smerdyakov: right.
<pango_>
strange, option is commented out in pervasives... it's defined earlier ?
<CoolPops>
Smerdyakov: my simple point was, all the experiments I was doing with type did not once say option in the return. but my other sql query was always displaying option so I thought it was something special in that case.
<Smerdyakov>
CoolPops, OK. Now that you know that 'option' is not a keyword, and since you have its definition, you should have no problem figuring this out, right?
<CoolPops>
Smerdyakov: correct.
<CoolPops>
but still curious why it would be used one place and not the other. that's confusing to me.
<pango_>
CoolPops: it's useful where you expect 0 or 1 result
<Smerdyakov>
CoolPops, I hope you've learned from this never to try a project on your own in a new language until you've read an entire tutorial on it. :)
<CoolPops>
Smerdyakov: I accomplished about 85% of it and got stuck on 1 piece. What programming project have you never been stuck on?
<CoolPops>
Smerdyakov: now that I under stand this, it's nearly complete.
<CoolPops>
Smerdyakov: I'll continue to learn the way I do. I read as much as I think I need to start experimenting. I experiment, get stuck, read some more. When I think I have some experince with what I read, then I will sit back down and read more until I feel I need to experiment. Then start the whole cycle again.
<CoolPops>
Smerdyakov: If I never experimented until I read the whole tutorial then I would have forgotten what I read at the beginning. Doing is a major part of learning.
<Smerdyakov>
CoolPops, I disagree. You should have a mental map of the features of a language before heading into unfamiliar territory. This has shown that you are effectively unable to handle the problems that show up, because you expect them to be too like what you're used to.
* CoolPops
might have been just a little too ambitious but with how close he came thought it was ok to ask 1 question he thought was simple.
<pango_>
CoolPops: if all you know C/Java/PHP, then I'd tend to agree with Smerdyakov. ocaml is quite different from those. It'd be sad if you used ocaml to program like you do with Java or PHP...
<pango_>
CoolPops: see what new things you can learn from it
<CoolPops>
pango_: your right. Part of the reason I am learning ocaml is to expand my horizons and learn different ways of doing things, not the same way in a different language.
<CoolPops>
but to sit down and read a tutorial w/o playing w/the language would just loose my by chapter 2.
<Smerdyakov>
Then maybe you need to work on your attention span if you want to be a good programmer.
kinners has quit [Nick collision from services.]
<Smerdyakov>
I read a whole SML book before writing any ML code.
kinners has joined #ocaml
<CoolPops>
Smerdyakov: people learn differently.
<mattam>
tutorials involve doing things most of the time, i thought
<Smerdyakov>
CoolPops, and there's no "fairness guarantee" saying that people with all learning styles are equally equipped to be good programmers.
<mattam>
moreover, with functional languages you usually have a toplevel to play with
<CoolPops>
Smerdyakov: I have about 15 programming books sitting next to me, all of which about 4 I read all the way through.
<CoolPops>
mattam: which my simple 4 line program was all done in.
<CoolPops>
anyway. I am sorry to cause such a problem. and I do appriciate the help and do not take advantage of irc. I help on many channels as well. #emacs, #php, #gentoo as well as commit to a few wikis. I'm not a leach.
<CoolPops>
and a few projects I released into open source got many good job type emails, so I feel I am a good programmer.
<CoolPops>
s/a/the/
<Smerdyakov>
Now, maybe you can be even better with ML if you take the time to learn it right. ;)
<CoolPops>
Smerdyakov: I am reading right now and will finish the tutorial, but not w/o playing.
<CoolPops>
Smerdyakov: I also printed one PDF book that is now sitting in a 3 ring binder which I will tackle after the tutorial.
<mattam>
oreilly's book ?
<CoolPops>
No, I didn't see that it was avail in pdf, is it?
<CoolPops>
Ah! it is. I got a link directly to /html/index.html ...
<CoolPops>
Would you guys consider it a good one?
<pango_>
CoolPops: "developping applications with objective caml"... I mainly used that one to learn... very progressive, I liked it
<mattam>
i do, i learned OCaml by myself using the french version
<mattam>
(and functionnal programming)
<Smerdyakov>
I would recommend learning SML first, personally, and I know a good online book for that.
<pango_>
(progressive ?)
* CoolPops
is waiting for inria.fr to come back up.
<Smerdyakov>
Oh, INRIA itself is always up. It's Projet Cristal that has problems.
<CoolPops>
I actually wanted to work through that book via the HTML interface (didn't know it had PDF) but I can't read it. I can only see the TOC because it's in my browsers cache.
<karryall>
a thread library (with the usual stuff, mutexes, conditions, etc)
<dan2>
cool
<karryall>
and two implementations, one with system threads, the other for bytecode programs only
<dan2>
karryall: I wouldn't see why you wouldn't want to use system threads
<karryall>
I guess some weird platforms don't support them
<dan2>
karryall: threads are an os thing; which os has yet to support threads and is still in use?
<karryall>
well the ocaml implementation is for POSIX threads and Win32 threads ; maybe some platforms have threads but not POSIX ones. Solaris maybe ? I don't know.
<pango>
dan2: there's also usually a limited number of system threads... If all you want is threads semantics, then vmthreads can be just fine
<pango>
dan2: I tried to translate the "round of message-passing processes" test of the languages shootout, that right now has only one implementation (erlang)
<pango>
dan2: it uses between 10000 and 100000 threads, something that few systems allow out of the box
<pango>
dan2: that works (slowly but fine) with vmthreads
cjohnson has quit [Read error: 110 (Connection timed out)]
cjohnson has joined #ocaml
Herrchen has quit ["leaving"]
<vincenz>
erlang has some sort of threads that are not posix threads...aka they're language threads (multiple fit in one posix-thread) that's why it's so good/fast at threadinge
<pango>
yes, more like vmthreads than threads
* vincenz
nods
<Riastradh>
Gambit 4 can apparently do somewhere around 1.4 million threads passing messages in a ring, if I remember correctly.
mpc has joined #ocaml
Maddas has joined #ocaml
mattam has quit [Client Quit]
Banana has quit [Remote closed the connection]
Banana has joined #ocaml
cjohnson has quit [Connection timed out]
cjohnson has joined #ocaml
mattam has joined #ocaml
mpc has quit []
mpc has joined #ocaml
cjohnson has quit [Connection timed out]
cjohnson has joined #ocaml
mpc has quit []
cjohnson has quit [Read error: 104 (Connection reset by peer)]
mpc has joined #ocaml
mrsolo has joined #ocaml
gpciceri has joined #ocaml
pango has quit [Read error: 110 (Connection timed out)]
bk_ has joined #ocaml
TylerE has joined #ocaml
<TylerE>
Anyone know of a good editor for hacking ocaml with in windows?
<Riastradh>
Emacs
<Smerdyakov>
Better still, an XWindows server. Run emacs on a remote Linux machine. :)
<avlondono>
even better, run vim instead of emacs ;-)
mpc has quit []
* TylerE
never really got on with either vi or emacs
<avlondono>
beware that vi is lame
<avlondono>
vim != vi
<avlondono>
emacs and vi can't be compared as editors, must say
<Riastradh>
Emacs isn't really an editor. It is a Lisp environment with many facilities geared for editing. (It also has a vim mode, viper-mode, that allows you to edit as though you were using vim.)
mpc has joined #ocaml
<avlondono>
that's why I said "as editors"
<Smerdyakov>
TylerE, maybe you ought to invest more time in giving it a try!
* avlondono
can't imagine programming anymore in anything different than vim (or emacs if necessary)
<mflux>
how about that emacs-clone written in ocaml, is it any good?
<Smerdyakov>
A _real_ emacs clone will allow safe, compiled extensions in any programming language, using certified code.
<mflux>
I don't think a programmer's editor needs to have so many safe guards, such as certified code. a word processor maybe.
<mflux>
and one would rather have the source for the extensions anyway ;)
<Smerdyakov>
Why would I want to run an extension that might scribble all over memory?
<mflux>
how does certifying a plugin guarantee it doesn't do that?
<Smerdyakov>
I mean certified code in the sense of proof-carrying code, typed assembly language, etc..
<mflux>
ohh, I thought certifying in cryptographical sense
<Smerdyakov>
Nah, that stuff is garbage.
<mflux>
well yes, that would be nice too, but do the tools exist for writing such code?
<mflux>
I wouldn't mind having a practical extension language.. ;)
<mflux>
the ocaml-emacs (the project's name escapes me) would be nice, but I don't think it's complete enough yet to replace xemacs
<Smerdyakov>
Yes. I and a bajillion other people have produced them in our research.
<Smerdyakov>
The thesis is that machine code is the best practical extension language.
<Smerdyakov>
Typed Assembly Language often works well enough, also.
<Riastradh>
That works, Smerdyakov, only if every languages' calling conventions are synchronized -- which typically just means convergence of style onto one dominant extension language whose calling conventions the others are made to match.
<Smerdyakov>
No.
<Smerdyakov>
Typed Assembly Language enforces no calling conventions.
<Smerdyakov>
(And clearly machine language doesn't, but I'm assuming you were addressing the second suggestion. ;)
<Riastradh>
Perhaps I ought to have been clearer: by 'that,' I meant 'machine code as the best practical extension language.'
<Smerdyakov>
I am assuming that relatively few 'calls' are made to extension modules.
<Smerdyakov>
The real gains, and reasons to favor some languages over others, come from internal processing.
<Riastradh>
Calls must be made _from_ extension modules.
<Smerdyakov>
OK, fine, relatively few calls cross language boundaries. Happy?
<Riastradh>
And not all extension modules stand alone; many of them are extension libraries.
<Riastradh>
No, I'm not happy. That is the case only because it is bothersome to perform those calls.
<Riastradh>
Most of the extension libraries will tend to be focussed on one dominant language.
<Smerdyakov>
What kind of problems are you foreseeing? There is remarkably little difference among implementations today that would affect this.
<Riastradh>
I am seeing problems of multilingual systems being effectively made monolingual by a dominant language, which defeats the purpose of multilingual systems in the first place.
<Smerdyakov>
I disagree, because cross-language calls need not be a common occurrence.
<Riastradh>
Fine. Instead, wheels will tend to be reinvented, because you _can't_ conveniently call the wheel that was already invented in another library written in another language.
<Smerdyakov>
You can with some care in designing implementations.
<Riastradh>
Elaborate.
<Smerdyakov>
There are a lot of commonalities that it is unfair to call restrictions.
<Smerdyakov>
When everyone's using a common garbage collector, calling conventions can be expected to be the same most everywhere.
<Smerdyakov>
You have continuation-based implementations doing quite zany things, but these seem to have been a fad that is now going out of favor.
<Riastradh>
It would perhaps have been better for me to discuss a higher-level concept than calling conventions.
mpc has quit []
<Riastradh>
A module written in, say, Prolog is not going to have the same design as a module written in, say, Scheme. Prolog & Scheme are dramatically different at very fundamental levels. Calling one from the other requires contorting the style of the code in an unsavory manner.
<Smerdyakov>
I don't see that. I think it's quite easy to write a generic wrapper for Prolog->Scheme, f'rinstance.
<Riastradh>
Do you claim that that will hold for every combination of extension languages used?
<Smerdyakov>
No, and I don't care.
<Smerdyakov>
I'm not advocating unlimited flexibility.
<Smerdyakov>
Just reasonable flexibility.
<Riastradh>
So it's just the languages that _you_ care about that would easily be able to call each other?
<Smerdyakov>
If "you" means the developer of the program to be extended, then yes.
<Riastradh>
So you have just completely contradicted your original goal, providing extension modules in arbitrary compiled code, irrespective of what it was compiled from.
<Smerdyakov>
No, I don't think so. I have explained more what I meant by "arbitrary."
<Riastradh>
I didn't see an explanation.
<Smerdyakov>
I mean that each application developer is free to develop his own interfaces, which constrain the types of extensions allowed.
<Riastradh>
...uh, so what's new about the thesis of which you spoke earlier?
<Smerdyakov>
The fact of a common method for ensuring interface compliant, regardless of the interface chosen.
<vincenz>
nitpicking cs'ers
<Smerdyakov>
vincenz, "nitpicking"? How so?
<vincenz>
just that I've read the discussion between you two
<Smerdyakov>
vincenz, demonstrate how it contains nitpicking, or get off the boat. :P
<vincenz>
unlimited flexibility and such are things that cs'ers usually seek
<vincenz>
instead of just oging with something that works, that might not cover all possibilities but that covers all possibilites that are used
<vincenz>
anyways
<Smerdyakov>
There is a large body of anecdotal evidence showing that allowing extension in a way that scales up to new language features is a hard problem.
<vincenz>
I have to get dinner, I haven't eaten yet today and I'm feeling lightheaded
<vincenz>
Smerdyakov: I know, so just make something that works instead of nitpicking over the fact that it's not *completely* language-independent
<Smerdyakov>
vincenz, you also get higher safety assurance by avoiding specifics.
<vincenz>
perhaps, but I think the whole argument before was a bit too abstract. imho tal or anything that's more ir-form will suit perfectly and if you want to add new claling conventions just add in a little adaptor
<vincenz>
Anyways, *me* is out for food :)
<vincenz>
s/claling/calling
<Riastradh>
Just to be a bit clearer, I _don't_ advocate trying to make it completely language-independent, because I know that such attempts will fail miserably and end up with a couple dominant languages, typically the most popular -- and frequently with least technical merit --; I like Emacs's general architecture as it is, ignoring the technical demerits of elisp.
<Smerdyakov>
That hypothesis has been invalidated every time it has been asserted for a system.
<Maddas>
Which hypothesis?
lmbdwr has joined #ocaml
<Smerdyakov>
"I have created a system which supports efficient extension using any programming language."
<Smerdyakov>
This is for systems that are based on something higher level than a usual kind of processor instruction set.
<Maddas>
Ok.
mpc has joined #ocaml
mrsolo has quit [Read error: 110 (Connection timed out)]
TylerE has quit []
pango has joined #ocaml
<vincenz>
I do think that creating such a system (if it's ever possible) will most likely introduce a lot of overhead.
<Smerdyakov>
No, you don't need any _runtime_ overhead.
<vincenz>
no runtime overhead
<vincenz>
but it won't be compiled as efficiently
<Smerdyakov>
"No runtime overhead" implies "compiled as efficiently as you want."
<vincenz>
calling conventions differences lead to extra assembly code to move stuff around
<Smerdyakov>
I'm talking about a generic system for verifying that code will execute safely.
<vincenz>
oh
<Smerdyakov>
I'm not talking about a magic emacs-clone interface that works for any calling conventions.
<vincenz>
alright
<vincenz>
besides isn't that a halting-problem-equivalent problem?
<Smerdyakov>
I claim that the first idea is much more important and challenging.
<Smerdyakov>
Once you have that, interfaces for emacs-clones are no big problem to create and enforce.
<Smerdyakov>
Sure, but luckily no one demands the ability to run all possible programs.
<Smerdyakov>
So we are no longer talking about the halting problem.
<vincenz>
hmm
<vincenz>
still
<vincenz>
don't certain recursive algorithms send the verificator in throws?
<Smerdyakov>
If you as the programmer understand why your (possibly recursive) code is safe, then a dumb computer sure ought to be able to figure that out with a few hints, eh?
<vincenz>
not quite
<vincenz>
some code has data-dependent conditions
<vincenz>
well lots of code does
<vincenz>
and thus termination is dictated by data
<vincenz>
you know eventually it will come, but the compiler can't know that
<Smerdyakov>
Again, I am assuming that the _programmer_ understands why, and that programmers are not willing to use very complicated safety preservation techniques.
<Smerdyakov>
Therefore, any such technique is easily checked by an automated tool.
<vincenz>
perhaps
<vincenz>
I guess my knowhow of how such tool is too limited to verify
<vincenz>
how such tool...works...
<Smerdyakov>
That is right. :)
<lmbdwr>
halting problem was ripped from russel's paradox
<lmbdwr>
which was itself probably ripped from someone else ;P
mrsolo has joined #ocaml
mpc has left #ocaml []
bk_ has quit ["Leaving IRC - dircproxy 1.1.0"]
mpc has joined #ocaml
mpc has left #ocaml []
mpc has joined #ocaml
gpciceri has quit [Remote closed the connection]
mpc has quit []
mlh has joined #ocaml
bk_ has joined #ocaml
cjohnson has joined #ocaml
bk_ has quit ["Leaving IRC - dircproxy 1.1.0"]
aaaa has left #ocaml []
mpc has joined #ocaml
mrsolo has quit [Read error: 104 (Connection reset by peer)]