<AirWolfTheme>
prints "Hello\n" and results into 10
<AirWolfTheme>
An expression can be composed of multiple sub expressions
rainbyte has joined #ocaml
<orion>
heh
<AirWolfTheme>
2 * 6 + 4 is one expression, but 2 * 6 is as well
<AirWolfTheme>
Since expressions have values, that they are composed of multiple expressions makes them useful.
<orion>
Is '2' a value or an expression?
<AirWolfTheme>
both
<orion>
!!!
<AirWolfTheme>
2 is an atomic expression
<AirWolfTheme>
its value is simply itself.
<AirWolfTheme>
Otherwise known as a data constructor.
<AirWolfTheme>
Nullary data constructor that is.
<orion>
ok
<gasche>
there is a different between "operator" and "expression constructor"
<gasche>
let .. = .. in ... construct expressions from bits (first bit is a variable, other are expressions)
<gasche>
.. ; .. is also an expression constructor
<AirWolfTheme>
let is fundamentally different though because it introduces scope.
rwmjones has quit [*.net *.split]
talzeus has quit [*.net *.split]
mfp has quit [*.net *.split]
smondet has quit [*.net *.split]
fayden has quit [*.net *.split]
noplamodo has quit [*.net *.split]
rz has quit [*.net *.split]
<gasche>
now .. .. is an expression constructor where both holes must be expressions (function application), and .. .. .. is an expression constructor where the middle thing is an infix operator
<gasche>
but .. ; .. is not a special case of the "infix operator" construction, it is a different syntactic rule (and semantics) entirely
<AirWolfTheme>
It is a special one as much as && and || are.
<AirWolfTheme>
They're all three operators with custom evaluation rules.
<gasche>
";" is not a syntactically valid infix operator
<gasche>
"&&" and "||" are, although they're also reserved keywords so it's best not to actually use them
<AirWolfTheme>
I suppose that's true, you can define let (&&) = whatever
rwmjones has joined #ocaml
talzeus has joined #ocaml
mfp has joined #ocaml
smondet has joined #ocaml
fayden has joined #ocaml
noplamodo has joined #ocaml
rz has joined #ocaml
<gasche>
a && b is ambiguous, the parser+typer sometimes recognize the expression constructor &&, and sometimes (when there is a "&&" operator in scope) uses the infix-operator construction
<gasche>
those are honest hackish special cases
<AirWolfTheme>
Actually, doesn't that make OCaml non context free
<AirWolfTheme>
now to think of it.
<gasche>
the parser does not see the different
<gasche>
*difference
<gasche>
so there is no *syntactic* ambiguity, only a semantic one
<AirWolfTheme>
Yeah, that s true I guess.
<gasche>
semantics are rarely-context free, as the meaning of "x" depends of the scoping environment
<gasche>
*on
<AirWolfTheme>
Well, you can say the same for the int x * y; problem with C
<AirWolfTheme>
that makes it non context free supposedly.
<gasche>
that said, I'm only nitpicking to vent air, your explanation to orion was clear and reasonable
<orion>
What kinds of problems are OCaml particularly good for solving? What problems is it *not* good for solving?
<AirWolfTheme>
I suppose you could theoretically keep the parser ignoring it.
<AirWolfTheme>
orion, ehh
<AirWolfTheme>
Ocaml is good for what static langauges are good at in general, bad for what dynamic languages are good at I guess
<AirWolfTheme>
gasche, I wouldn't say I agree, they can implement any application really.
<AirWolfTheme>
Web server is one of those things where dynamic typing is bette rI feel.
<AirWolfTheme>
Correctness isn't nearly as important as just getting stuff done quickly.
<gasche>
they are *really good* at symbolic manipulation, in the sense that they're the best we have by a clear margin
<AirWolfTheme>
Also, extensive string manipulation with static typing can be a hasstle.
<AirWolfTheme>
True
FreeArtMan has joined #ocaml
<gasche>
OCaml is reasonable for systemish programming like a web server, it's only not much better than other choices
<orion>
I see.
<gasche>
I'm not sure what static typing implies for string manipulations
<gasche>
well it's much better than C because you don't die with security attacks over a poorly-allocated string
<gasche>
but that's not the right standard to compare to anymore
<AirWolfTheme>
Well yeah, there's that, C is pretty awful for string manipulation obviously.
<f[x]>
statically typed language shines at string manipulation
<f[x]>
precisely
<AirWolfTheme>
OCaml has that format hack though
<gasche>
also orion OCaml being compiled in a reasonable way is faster than dynamic languages (but sometimes slower than highly-optimized compilers on some problem domains, eg. heavy floating-point numerics in C or Fortran)
<AirWolfTheme>
A lot of static languges don't have printf like functionality and at the very least not with runtime strings.
FreeArtMan has quit [Client Quit]
<AirWolfTheme>
Well, here's the other point, speed does not really matter with web servers at all.
<gasche>
well
<AirWolfTheme>
THe bottleneck is always going to be the internet connexion, you can spam a page together quite quickly
<gasche>
insist on neither speed nor correctness, recommend Ruby, and you'll have a web server framework that is indeed convenient but has to be restarted every ten minutes because of memory leaks and unknown problems
ggole has joined #ocaml
<AirWolfTheme>
Ahaha
<AirWolfTheme>
Is Ruby really that bad?
<orion>
Consider a bit torrent client, which has a strong concept of state. Would this be next to impossible to write in a functional language?
<gasche>
no, perfectly easy
<AirWolfTheme>
PHP is honestly kind of good at what it does, the language itself is bloody horrible but iut does have all the libraries you will ever need for this
<AirWolfTheme>
it specializes on one thing and is concordantly completely filled with stuff to make that one thing as easy on you as possible.
<gasche>
AirWolfTheme: I'm frankly not so sure about the libraries point
<AirWolfTheme>
Why?
<gasche>
back in the days were I used PHP, I wanted something reasonably obvious
<AirWolfTheme>
It gives you everything, DOM, XML treatment, RSS parsing, mysql interfacing.
<gasche>
which is to show the diff of two modifications to an user of a content-production system
<orion>
What aspects of functional programming make writing something stateful like a bit torrent client easy?
<gasche>
functional programming encourage you to represent state explicitly
<AirWolfTheme>
Why is a bit torrent client that stateful?
<AirWolfTheme>
The problem is I guess that many people new to FP try to simulate state in FP while the correct approach is to minimize it unless you absolutely need it.
<gasche>
besides, OCaml has mutable state if you want it, so if you really think global mutable variables are the best choice, you can go for it
<AirWolfTheme>
You often see people write tail recursive loops similar to while loops while something like a fold would suffice.
jao has joined #ocaml
jao has quit [Changing host]
jao has joined #ocaml
<gasche>
interestingly, one of the most exciting bitorrent clients I know about has been written in CPC, which is precisely a dialect of C enriched with old ideas of functional programming
<AirWolfTheme>
Holy wow, it actually stands for tha,t ahaha
<gasche>
(back to work; have fun!)
<gasche>
companion_cube: let me know when the opam PR is accepted
<def-lkb>
(well, it's a seeder not a client -- there is much more concurrency in a seeder)
<gasche>
yeah, sorry
<def-lkb>
np
<orion>
This whole concept is FP is titillating.
<AirWolfTheme>
I wish I was smart enough to know that word but it looks to me like stimulating someone's nipples.
<adrien>
s/nipples/brain/ and you have it
<adrien>
rather than brain: curiosity
<adrien>
(implied)
FreeArtMan has joined #ocaml
<orion>
"adjective; arousing mild sexual excitement or interest"
<AirWolfTheme>
Ahh, I was close.
<orion>
I am an ENTJ, so mental stimulation feels just as good as sexual stimulation.
<AirWolfTheme>
orion, anyway, I like to see FP as the next evolution like structured programming, it's a restriction more than anything you place to make code more readable and maintainable, much like not using gotos.
<adrien>
well, "titiller" exists as a verb in french and it's actually "titiller $something", i.e. it can be used for anything you ant
<orion>
AirWolfTheme: It certainly seems that way.
<orion>
I could certainly get behind OCaml if it had a rich set of libraries.
olliefr has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
<AirWolfTheme>
Well, you have the Core and batteries project.
<gasche>
functional programming is the *natural* result of designing a language in which code needs not be duplicated, and factorization is easy
<gasche>
hm
<orion>
Specifically, I need AES, SHA256, DSA, ElGaml, networking, and sqlite.
<orion>
I've already got 12,000 lines of C++ written, so I think I am going to write a C89 interface for it, compile it has a library, and then finish it off in OCaml with the FFI.
<adrien>
hmmmmm
* adrien
has some doubts about that approach
<gasche>
Thomas Leonard (zeroinstall's author) is currently writing very interesting things about porting systemish code from Python to OCaml
<gasche>
and Richard Jones at Red Hat has experience with using OCaml for some systemish tools interacting with the rest of the system (say libvirt stuff)
<gasche>
(adrien is a grumpy expert on using decaying GUI frameworks from OCaml)
<orion>
Is it difficult for functional languages to bind to something written in an imperative language?
<adrien>
(you forgot the win32 aspect)
<adrien>
gasche: actually I'm mostly using what works and has a nice ocaml API
<adrien>
next stuff I do is quite likely to be done using EFLs
<f[x]>
bittorrent client is a nice example
<f[x]>
because there is already one in ocaml
<f[x]>
and has some unmatched features
FreeArtMon has joined #ocaml
<orion>
adrien: I admit that it might be stupid to write a library in C and use it in OCaml. Why could it be a bad idea though?
<adrien>
the existing code hasn't been written with that in mind
<adrien>
you'll have to learn the ocaml ffi probably and that means learning the ocaml internals too (well, internals of the runtime)
<adrien>
and you'll be learning a new langage mid-project
<orion>
Let's say that hypothetically the project -- from the very beginning -- was meant to be a library with a C89 interface.
FreeArtMan has quit [Ping timeout: 272 seconds]
<adrien>
then definitely doable
<orion>
interesting
<adrien>
main question being whether writing bindings is more or less time than rewriting as ocaml
zarul has quit [Read error: Connection reset by peer]
<orion>
12,000 lines?
<orion>
It's interesting me that you guys are so confident in what a functional language can do.
<adrien>
but in one of my project I've written bindings to two functions of 200 lines of C each rather than binding the low-level blocks that would have allowed me to write the logic in ocaml
zarul has joined #ocaml
<adrien>
(there was no point in doing so)
<adrien>
ocaml is general purpose and everything (up to the community) is pragmatic
<AirWolfTheme>
orion, well, they are turing complete.
<AirWolfTheme>
Except agda.
<orion>
AirWolfTheme: What strikes me is that you have an entirely different way of thinking.
<AirWolfTheme>
you plural or you singular?
<AirWolfTheme>
ye or thou?
<orion>
hah
<orion>
true
<orion>
It's like visiting Manhattan for the first time and seeing cars double parked on the sidewalk.
<AirWolfTheme>
orion, whatś so different?
<orion>
If you live in Manhattan, it makes total sense (you'll get ticketed if you park on the street on certain days).
<orion>
But if you're from the country, it's completely mind blowing.
<AirWolfTheme>
orion, but what's so weird?
<orion>
The way you approach problems.
<orion>
As soon as someone tells me what they want to accomplish, I start thinking about classes, inheritance, and templates.
<adrien>
it mostly boils down to taking more time to think about the problem
<orion>
And I built a mental map.
<orion>
But from what I've seen so far with functional languages, it's a completely new way of thinking about the problem.
<adrien>
then device a few types and write the code that flows from the types
<AirWolfTheme>
templates are a poor man's parametric type.
<def-lkb>
orion: I used to think more or less that way, I discovered FP ~4 years ago and got really hooked; I'll never come back to OOP ;)
<orion>
heh
<AirWolfTheme>
I never learnt to program empirically.
<orion>
def-lkb: I have a feeling that I will be the same way. It makes me feel like my 12,000+ line C++ library has been a waste of time.
<AirWolfTheme>
First language I learnt was scheme, even in python and php I program functionally.
<Anarchos>
def-lkb OOP is nothing more than a struct with fields, and some fields are pointer to function....
<AirWolfTheme>
Alan Kay kills a bunny every time you say that.
<adrien>
^ ^
Eyyub has joined #ocaml
<def-lkb>
FWIW, it took me two attempts to stop thinking in an OOP-ish way (trying to reencode OOP-patterns in FP brought me worst of both worlds)
<AirWolfTheme>
You can OO without mutation though.
<AirWolfTheme>
Being able to do "string"#ref 1 or something wouldn't hurt.
<orion>
What is the biggest mistake people make when learning OCaml, *assuming that they've never programmed in their life*?
<AirWolfTheme>
Learning OCAml as their first language.
<orion>
yes
<AirWolfTheme>
Always start with Scheme
<AirWolfTheme>
Always
<orion>
Essentially, someone whose mind isn't polluted with OO.
Eyyub has quit [Read error: Operation timed out]
<AirWolfTheme>
Nothing wrong with OO
<adrien>
I wouldn't say that
<adrien>
I've never done scheme
<AirWolfTheme>
It attempts to do muchj the same things that FP does, decomposition of code into smaller more maintainable elements, easier to read stuff and what not.
<AirWolfTheme>
THat is exactly why you wouldn't say that.
<adrien>
the most common mistake is trying to start with ocaml objects
<adrien>
they are *not* a beginner topic
FreeArtMon has quit [Read error: Operation timed out]
<adrien>
they are not needed for most ocaml code
<AirWolfTheme>
Also, no one uses them ever.
<adrien>
that's wrong
<AirWolfTheme>
No it's not.
<adrien>
ocamlnet, lablgtk?
<AirWolfTheme>
They don't count.
<adrien>
ah
<Thooms>
:D
<adrien>
(I have commit rights in lablgtk, and even use them when I have time to)
tobiasBora has joined #ocaml
<AirWolfTheme>
I have no idea what lablgtk is.
lostcuaz has quit [Ping timeout: 272 seconds]
<AirWolfTheme>
But if someone who doesn't know scheme has commit rights on it it can't be good.
<AirWolfTheme>
Probably some kind of sleasy porn search engine
<orion>
What the hell is a "unit"?
lostcuaz has joined #ocaml
<adrien>
orion: "nothing" :)
<adrien>
AirWolfTheme: you can look it up
<def-lkb>
a type that has only one value… similar to "void" in C-ish languages
<orion>
# "a"; "beautiful"; "day";;
<orion>
Warning 10: this expression should have type unit.
<AirWolfTheme>
orion, basically needed because every expression has to have a type.
<AirWolfTheme>
orion, , oh yeah
<AirWolfTheme>
that's the part about sequencing I flat out forgot
<def-lkb>
(bool has two values, either true or false, void is just void… that's why it's "unit", and its value is noted () )
<AirWolfTheme>
Functions like print in Ocaml are typed string -> unit
kyrylo has joined #ocaml
<AirWolfTheme>
As in, their return value is the singleton value that exists in unit, as in "this value isn't interesting"
<adrien>
orion: that warning means that if you're to not use an expression, then that expression should be of type "unit", otherwise you're computing something uselessly since you're throwing it away
<AirWolfTheme>
You can only of course sequence uninteresting values because "a" ; "day" would be a waste for "a"
<orion>
So the warning is that I am essentially wasting my time with "a" ; "beautiful"
<gasche>
use (ignore "a"; "beautiful") or (let _ = "a" in "beautiful") to avoid the warning
<adrien>
orion: but you can build a list with [ "a"; "beautiful"; "day" ]
<adrien>
;-)
<orion>
Is there a way I can query the type of a value on the CLI?
<gasche>
just type it
<gasche>
ah
<orion>
hmm
<adrien>
orion: do you have an example of what you'd like the type of?
<orion>
- : string list = ["a"; "beautiful"; "day"]
<adrien>
and why not inside the toplevel?
<orion>
I don't know what that means.
<adrien>
the ocaml process
<adrien>
it accepts input, evals it, return the result
jao has quit [Ping timeout: 252 seconds]
<AirWolfTheme>
adrien, you mean get it as runtime value?
<def-lkb>
CLI refers to executing and sequencing programs, passing them arguments; toplevel is the REPL/ocaml shell/prompt you get when executing specifically the "ocaml" command
<AirWolfTheme>
utop is better anyway
<AirWolfTheme>
One of the finer interactive repls I used
<Drup>
also, stop the scheme fanboy thingy, scheme is nowhere near as interesting as people believe it is.
<orion>
Why does line 2 work but line 5 fails?
FreeArtMon has joined #ocaml
<def-lkb>
orion: it's parsed as "open Printf printf …"
<def-lkb>
write "open Printf;;" to separate sentences
<AirWolfTheme>
Drup, that link pretty much agrees with my thesis though.
<Drup>
no it does not =)
<AirWolfTheme>
And scheme is a cool teaching language because it enables you to build almost anything from language primitives.
<orion>
ok
<AirWolfTheme>
Thereby explaining how those things work
<orion>
So, you can elide ;; when there's a let or open.
<adrien>
I'm fairly sure objects are going to remain more used than GADTs, yet noone would think about removing GADTs from OCaml nor would call them useless
<adrien>
orion: ";;" means "end of sentence"
<adrien>
orion: a "sentence" is a set of chars that can be parsed properly
<orion>
Is "let f a b c = 2;;" a declaration, sentence, or both?
<AirWolfTheme>
Ocaml has GADT's?
<AirWolfTheme>
Well there you go, clearly my ignorance has been proven.
<AirWolfTheme>
I'm also not saying that ocaml objects should be removed, I'm just saying it's humourous how the language names itself after adding them and they are basically almost never used.
<adrien>
orion: a sentence is simply used to denote something that can be parsed and handled on its own; I don't think the concept is kept later down in the compilation process
<orion>
ok
<orion>
I am still not entirely clear on scope.
<orion>
When is a new scope created?
<adrien>
very often? :P
<adrien>
but you can:
<adrien>
let a = 42 in let a = 0 in a
<AirWolfTheme>
A local scope is basically the exprsesion following the 'in' in 'let ... in ...'
<AirWolfTheme>
Where 'let ... in ...' is itself an expression
<adrien>
the second definition of "a" shadows the first one, yet the two variables are different
<AirWolfTheme>
hence you can do the above.
<adrien>
(thought that might be what you find weird at the moment)
<AirWolfTheme>
C also has lexical block scope that can go to infinite depth no/
<orion>
Is the usage of "in" the only way scope is created?
<Thooms>
orion: no, you create also a scope when defining a function
<AirWolfTheme>
Well, if you don't use in at the top level if effectively does something similar.
<adrien>
parens, begin/end, if/then/else, object...end, struct...end, and also functions and probably a few others
<Thooms>
let f x = (* scope containing x *)
<AirWolfTheme>
fun creates the scope though, you don't need to 'define' it to create it.
<orion>
well wait
<AirWolfTheme>
fun x -> x * 1 also has a scope as an anonymous function, as in the 'let' does not create the scope there, the fun does.
<orion>
What is the difference between nesting a function within another function and using 'in'?
<AirWolfTheme>
In fact, let <identifier> = <exp> in <exp2> is the same as "(fun <identifier> -> <exp>) <exp2>"
<AirWolfTheme>
A local scope is basically just a function applied immediately.
<Drup>
AirWolfTheme: you need to switch exp and exp2
<AirWolfTheme>
Ehh yeah that's true
<orion>
Are operators types?
<AirWolfTheme>
They have types.
<AirWolfTheme>
Assuming you mean infix operators
<AirWolfTheme>
which are basically functions
<AirWolfTheme>
It's just an alternative syntax for function calls.
<orion>
Can I get the type of an operator from toplevel?
<AirWolfTheme>
# (+)
<orion>
;;
<AirWolfTheme>
To reify it as a normal function just put ( ... ) around it, but with * you have to be careful because (* ... *) is a comment so do ( * ) for * and *.
<AirWolfTheme>
And yeah, ;; needs to come after it
FreeArtMon has quit [Ping timeout: 272 seconds]
<orion>
hmm
<orion>
How come > has type 'a -> 'a -> bool = <fun> but + has type int -> int -> int = <fun> ?
<AirWolfTheme>
Well, because > works on anything
<orion>
In other words, why do you need two operators for addition of floats and ints, but only one for comparison?
<AirWolfTheme>
I don't think it actually does by the way, I think there's something with hash tables that it rejects
<AirWolfTheme>
Well, because > works on anything, it also works on strings.
<orion>
Why can't you have one + operator that works for floats and ints?
struktured has joined #ocaml
<AirWolfTheme>
Because then + would have to work on anything
<AirWolfTheme>
A function works on one type or all types.
<AirWolfTheme>
Haskell has a system of typeclasses to be able to let a function work on say 5 types if you want to, in Ocaml paramatrized modules sort of solve the same problem for you
<AirWolfTheme>
Basically, they could make (=) and (>) work sensibly on all things but they couldn't do it for +. If you ask me making (>) work on everything is a quaint decision
<adrien>
they compares bits
<adrien>
well
<AirWolfTheme>
Yeah, I know, which is what the weird semantics of it is.
mort___ has joined #ocaml
<adrien>
they check the kind of the value of runtime and if it's not integer/float/..., they compare bits
<AirWolfTheme>
It gets pretty deeply into the internals
<AirWolfTheme>
orion, also, another thing is that if + was polymorphic it would have to be 'a -> 'a -> 'a, as in, return the same type of the things compared.
<AirWolfTheme>
Which would mean that hash table + hash table = hash table, what hash table exactly?
<AirWolfTheme>
(=) and (>) are going to bool so that helps here.
<orion>
ok
<orion>
When you do let ... ;; are you defining a function or a value? Or is a function merely a kind of value?
f[x] has quit [Ping timeout: 260 seconds]
mort___ has left #ocaml []
thomasga has joined #ocaml
<Kakadu_>
functions are values
<orion>
ok
<adrien>
almost everything is a value
<orion>
heh, is there a venn diagram with all the vocabulary used here?
<AirWolfTheme>
orion, except when people say that 'let ... = ... ;;' creates a scope
<AirWolfTheme>
that's only when itś a function and it's not the let that creates the scope but the function
<mrvn>
How do I sleep 0.x seconds? Any alternative to Unix.select?
<adrien>
mrvn: are you using additional libs?
<mrvn>
adrien: only zmq so far
kyrylo has quit [Quit: Hi, Rob!]
mhi^ has quit [Quit: Lost terminal]
zpe has joined #ocaml
Simn has joined #ocaml
Thooms has quit [Quit: WeeChat 0.3.8]
zpe has quit [Ping timeout: 252 seconds]
mfp has quit [Read error: Connection reset by peer]
<orion>
What's the difference between a tuple and a list?
<orion>
"Unlike lists, tuples can contain elements of different types" -- nevermind
<Kakadu_>
Are you familiar with std::pair?
<orion>
yes
ulfdoz has quit [Ping timeout: 264 seconds]
<Kakadu_>
So, pir contains two elements, tuple contains many and its number is encoded in type
<Kakadu_>
pair*
<Kakadu_>
List contains many elements too, but they all should have same type
<AirWolfTheme>
a pair is a tuple of 2, a tuple of 1 is just the thing itself, shoyuld bve noted
<AirWolfTheme>
orion, in fact, the singular value in unit is commonly seen as a tuple of zero things.
<AirWolfTheme>
As in 'contains nothing, just here to be a value'
<mrvn>
A ref is a one tuple which isn not the thing itself.
struktured has quit [Ping timeout: 246 seconds]
ontologiae has quit [Ping timeout: 272 seconds]
mfp has joined #ocaml
<AirWolfTheme>
A ref is basically a mutable record with one thing though.
<AirWolfTheme>
tuples can't have mutable contents as far as I know but maybe I'm wrong here.
<AirWolfTheme>
A tuple of one would be useless, the major use of a record of 1 is that you can ehh, make it mutable I guess
<mrvn>
yes. In memory records and tuples are the same.
<AirWolfTheme>
Also, records have names which can make code clearer, tuples don't.
<mrvn>
labels
<AirWolfTheme>
True, but then again, so are integers and characters
mcclurmc has joined #ocaml
teethed_bird has joined #ocaml
<orion>
Is it possible to make an application segault?
<Kakadu_>
possible
<adrien>
if you're using only the ocaml language, no
<adrien>
FFI is an efficient way to segfault however
<adrien>
black magic too
<adrien>
dark*
<orion>
If I didn't load Pervasives, what types would be available?
<Kakadu_>
Is Obj.magic a dark one?
<adrien>
definitely
<mrvn>
totaly
dant3 has quit [Remote host closed the connection]
<Kakadu_>
orion: Pervasives are loaded automatically
<adrien>
orion: you'd have to use -nostdlib to do that
<adrien>
and in that case
FreeArtMan has joined #ocaml
<mrvn>
You can only segfault with Obj, *_unsafe or broken C bindings
<adrien>
not many things
dant3 has joined #ocaml
<orion>
Would you have integers?
<adrien>
yes
<adrien>
arrays, lists, floats
<adrien>
chars, strings, ...
<adrien>
check the doc of Pervasives and look for type definitions
<adrien>
orion: but it's usually not a good idea to try to avoid Pervasives :P
<adrien>
need to go
<orion>
It's interesting to me that Pervasives includes "type int" when it's already provided by the language.
<adrien>
I don't see it
<mrvn>
some things are simply hardcoded in the compiler
mcclurmc has quit [Remote host closed the connection]
thomasga has quit [Quit: Leaving.]
mcclurmc has joined #ocaml
teethed_bird has quit [Quit: Page closed]
struktured has joined #ocaml
jao has joined #ocaml
jao has quit [Changing host]
jao has joined #ocaml
mcclurmc has quit [Remote host closed the connection]
<orion>
Why did the author do "let _ = ..." at the bottom of test.ml?
<adrien>
noticed how there is no "main" function in ocaml?
<AirWolfTheme>
orion, let () = ... is a more common idiom, that said, the OCaml entry point is anonymous, you can effectively see your entire file as a 'main function'
<AirWolfTheme>
it just executes the expressions in order in the file, the let _ = is actually not needed
<AirWolfTheme>
But both let _ = print_endline "Hello, World";; and print_endline "Hello, World" do the same
<AirWolfTheme>
You basically assign the return value of that expression to nothing, which is the empty tuple, only member of unit
<orion>
AirWolfTheme: If you remove "let _ = ..." from the file, the application does not do anything.
<AirWolfTheme>
ehh, maybe I should actually look instead of asuming then
<AirWolfTheme>
Oh, it's actually a scope
avsm has quit [Quit: Leaving.]
shinnya has quit [Ping timeout: 248 seconds]
<AirWolfTheme>
orion: you mean this:
<AirWolfTheme>
let _ = Thread.create conn_main s in
<AirWolfTheme>
accept_loop sock
<adrien>
orion: all top-level constructs are evaluated upon module loading
<adrien>
this means the right side of "=" will be evaluated
<AirWolfTheme>
That's basically the same as (Thread.create conn_main s ; accept_loop sock)
<orion>
Oh, the reason the application does nothing is because I needed to add ';;' after accept_loop sock.
<adrien>
hmmmmm
<adrien>
looks wrong
<adrien>
orion: the code just got merged with the code two lines above
<adrien>
or something like that
<adrien>
but it's quite surprising the code parsed and type-checked
<adrien>
but I bet you've changed its meaning
<AirWolfTheme>
That is why I think both 'let' for local scope and top level bindings is a quaint decision.
ulfdoz has joined #ocaml
<AirWolfTheme>
An error should throw an error as often as possible, not also be valid code for something which you may not have intended.
<adrien>
err, no
<adrien>
I meant that for _removing_ the "let _ ="
<adrien>
so quite the opposite
avsm has joined #ocaml
<orion>
Thanks for all your help guys.
orion has left #ocaml []
<AirWolfTheme>
And gone she went, into the night, without giving a chance to say "you're welcome"...
<Kakadu_>
AirWolfTheme: Google doesn't know this lyrics..
<AirWolfTheme>
I just made it up on the fly.
kyrylo has joined #ocaml
avsm has quit [Quit: Leaving.]
mocrunsthecity has joined #ocaml
kyrylo has quit [Quit: Hi, Rob!]
thomasga has quit [Quit: Leaving.]
xian has left #ocaml []
avsm has joined #ocaml
ggole has quit []
thomasga has joined #ocaml
thomasga has quit [Client Quit]
mathieui has left #ocaml []
AirWolfTheme is now known as KnightRiderTheme
dant3_ has joined #ocaml
dant3 has quit [Ping timeout: 252 seconds]
<mrvn>
ARGS, I just realized why 'if str == "QUIT" then raise QUIT' wouldn't quit
milosn_ has joined #ocaml
yacks has quit [Quit: Leaving]
milosn has quit [Read error: No route to host]
ulfdoz has quit [Ping timeout: 252 seconds]
Kakadu_ has quit []
jao has quit [*.net *.split]
tobiasBora has quit [*.net *.split]
pango has quit [*.net *.split]
manizzle has quit [*.net *.split]
samebchase has quit [*.net *.split]
xaimus has quit [*.net *.split]
seliopou has quit [*.net *.split]
mal`` has quit [*.net *.split]
cdidd has quit [*.net *.split]
Drup has quit [*.net *.split]
NoNNaN has quit [*.net *.split]
Arach has quit [*.net *.split]
<KnightRiderTheme>
mrvn, because == is memory location compare?
jao has joined #ocaml
tobiasBora has joined #ocaml
pango has joined #ocaml
NoNNaN has joined #ocaml
manizzle has joined #ocaml
samebchase has joined #ocaml
xaimus has joined #ocaml
Arach has joined #ocaml
seliopou has joined #ocaml
mal`` has joined #ocaml
cdidd has joined #ocaml
Drup has joined #ocaml
<mrvn>
KnightRiderTheme: yes
<KnightRiderTheme>
I don;'t really get these polymorphic >, =, == etc but hey.
<KnightRiderTheme>
I get a polymorphic physical identity compare.
<KnightRiderTheme>
Can you do physical location ordering on strings in some way anyway?
<KnightRiderTheme>
(>) : string -> string -> bool gives you sequential codepoint compare if I'm not mistaken
<companion_cube>
they are magical :/
<KnightRiderTheme>
Well yeah, but I'm just wondering, is it at all possible in some way to do a physical identity ordering on a string?
mort___ has joined #ocaml
dant3_ has quit [Remote host closed the connection]
dant3 has joined #ocaml
<KnightRiderTheme>
companion_cube, answer me
<KnightRiderTheme>
you seem like someone who knows stuff.
<KnightRiderTheme>
companion_cube, why would you keep me bereft of knowledge, I would never incinerate you. =(
mort___ has quit [Quit: Leaving.]
mort___ has joined #ocaml
axiles has quit [Remote host closed the connection]
kyrylo has joined #ocaml
mort___ has quit [Ping timeout: 260 seconds]
<gasche>
KnightRiderTheme: when the GC can move stuff, pointer equality makes sense, but order doesn't
<gasche>
except (==), polymorphic comparison therefore traverse values and compare by content
<gasche>
which is why they're often called "structural" by opposition to "physical"
FreeArtMan has quit [Ping timeout: 272 seconds]
<KnightRiderTheme>
Yeah, but > isn't structurual on everything
<gasche>
?
<KnightRiderTheme>
It is on strings and stuff, but not on arbitrary records or hash tables or what not
<KnightRiderTheme>
gasche '>' does memory location compare on other stuff than numbersa dn strings right?
<KnightRiderTheme>
Might have forgotten one.
<KnightRiderTheme>
The point is, > works on a list of hashtables.
<gasche>
but it works by traversing the runtime representation of the hasthable
<gasche>
(which is not necessarily what you want as a hashtable and its same-elements-but-resized will be different)
<KnightRiderTheme>
Is it?
<gasche>
it does something or fail with an error, but when it works it is structural
<KnightRiderTheme>
I thought that > on hash tables or on anything which is not some primitive type does memory location compare.
<KnightRiderTheme>
Really.
<gasche>
as I said above, you can't because of the GC
<KnightRiderTheme>
I am pretty sure that is not true.
<KnightRiderTheme>
At least, that is not how I read it everywhere, as far as I know (>) is structural on a select few primitive types and works with memory location for anything else
<gasche>
on objects it compare by integer identifiers
<gasche>
and on "custom" values it calls the registered custom comparison operation when available
<KnightRiderTheme>
Hmm
<KnightRiderTheme>
So what would happen if you have a list of objects
<KnightRiderTheme>
and do > on it?
<KnightRiderTheme>
It cmopares it sequentially?
<gasche>
two lists of objects ?
<KnightRiderTheme>
Yeah
<gasche>
it will compare the heads of the list
<gasche>
if they're different, return different
<gasche>
else look at the rest of both lists
<KnightRiderTheme>
So it does a sequential one one on lists?
<gasche>
(objects would be compared by numeric identifier)
<gasche>
it's a structural comparison, yes
milosn_ has quit [Ping timeout: 246 seconds]
mocrunsthecity has quit [Remote host closed the connection]
milosn has joined #ocaml
tobiasBora has quit [Quit: Konversation terminated!]
milosn_ has joined #ocaml
avsm has quit [Quit: Leaving.]
kyrylo has quit [Quit: Hi, Rob!]
avsm has joined #ocaml
kyrylo has joined #ocaml
avsm has quit [Ping timeout: 252 seconds]
darkf has joined #ocaml
mk270 has joined #ocaml
Simn has quit [Quit: Leaving]
avsm has joined #ocaml
Anarchos has quit [Quit: Vision[0.9.7-H-20131020]: i've been blurred!]
avsm has quit [Ping timeout: 260 seconds]
madroach has quit [Ping timeout: 252 seconds]
madroach has joined #ocaml
dant3 has quit [Remote host closed the connection]
skchrko has joined #ocaml
skchrko has quit [Remote host closed the connection]