dmbaturin has quit [Remote host closed the connection]
dmbaturin has joined #ocaml
demonimin has joined #ocaml
dmbaturin has quit [Ping timeout: 260 seconds]
dmbaturin has joined #ocaml
MrScout has joined #ocaml
manizzle has joined #ocaml
dsheets has quit [Ping timeout: 258 seconds]
SomeDamnBody has joined #ocaml
madroach has quit [Ping timeout: 250 seconds]
shinnya has quit [Ping timeout: 265 seconds]
madroach has joined #ocaml
zpe has joined #ocaml
ontologiae has joined #ocaml
NoNNaN has quit [Remote host closed the connection]
NoNNaN has joined #ocaml
q66 has quit [Remote host closed the connection]
zpe has quit [Ping timeout: 250 seconds]
AltGr has joined #ocaml
manud has joined #ocaml
ontologiae has quit [Quit: WeeChat 1.0]
sheijk has quit [Ping timeout: 260 seconds]
triskiii has joined #ocaml
manud has quit [Quit: manud]
araujo has joined #ocaml
SomeDamnBody has quit [Ping timeout: 255 seconds]
SomeDamnBody has joined #ocaml
MrScout_ has joined #ocaml
thomasga has quit [Quit: Leaving.]
MrScout has quit [Ping timeout: 272 seconds]
MrScout_ has quit [Ping timeout: 244 seconds]
araujo has quit [Quit: Leaving]
darkf has joined #ocaml
manud has joined #ocaml
MrScout has joined #ocaml
NoNNaN has quit [Remote host closed the connection]
darkf has quit [Ping timeout: 244 seconds]
patojo has quit [Remote host closed the connection]
<SomeDamnBody>
does anybody know much about creating RPC services to ocaml code via piqi?
lordkryss has quit [Quit: Connection closed for inactivity]
darkf has joined #ocaml
sheijk has joined #ocaml
NoNNaN has joined #ocaml
zpe has joined #ocaml
sheijk has quit [Ping timeout: 244 seconds]
zpe has quit [Ping timeout: 258 seconds]
rgrinberg1 has joined #ocaml
MrScout has quit [Remote host closed the connection]
MrScout has joined #ocaml
manud has quit [Quit: manud]
MrScout has quit [Ping timeout: 255 seconds]
<rgrinberg1>
companion_cube: i'm releasing bencode 1.0.0 MIT licensed ok? Seems like that some people don't like WTFPL
<Drup>
rgrinberg1: ahah
<rgrinberg1>
haters :/
<Drup>
I indeed remember "someone" complaining about one of my library for that, except if was library only useful for eve online's api, so I was ... not very receptive to the complain. =)
<Drup>
rgrinberg1: tbf, there is a real issue with wtfpl, is that it's not valid in most countries, so your code is in fact still copyrighted (as default in the relevant country)
<rgrinberg1>
yeah, easier to just side step all this crap
<rgrinberg1>
btw, since when did opam add a "findlib" file?
<Drup>
oh
<Drup>
that was auto-generated, you're not supposed to do it
<Drup>
AltGr was not very clear on the current purpose of the file
<rgrinberg1>
I see. thanks. opam/findlib integration would be cool
<AltGr>
it's from the opam repo, not opam itsemf; just investigating a way to help sort things out
<rgrinberg1>
btw, did I miss the death of assemblage somewhere? Seems to have been quietly abandoned
<AltGr>
just a case where I didn't handle the unavailability of an already installed package as well as I expected
<AltGr>
(I must say repo maintainers put quite the stress on opam on this one ;))
<Drup>
:p
<Drup>
anyway, wrt to ocp-browser, I think it's quite ready know
<Drup>
at least, I'm using it on an everyday basis, and the only bug I can find are in libIndex :D
<AltGr>
cool!
oc has joined #ocaml
<Drup>
there is still something in the code that could be backported to lambda-term, but it's not that simple to backport cleanly and it can be done later anyway, it's purely internal
<Drup>
oh, and, the modal help on alt+h looks cool <3
claudiuc has quit [Remote host closed the connection]
<Drup>
now, bet time, happy bug fixing :)
hausdorff has quit [Remote host closed the connection]
Submarine has quit [Remote host closed the connection]
zpe has quit [Ping timeout: 265 seconds]
hausdorff has joined #ocaml
rgrinberg1 has quit [Quit: Leaving.]
triskiii has quit [Ping timeout: 244 seconds]
arboris has quit [Quit: Lost terminal]
utrulo has joined #ocaml
manud has quit [Quit: manud]
taion809 has quit [Remote host closed the connection]
sheijk has joined #ocaml
siddharthv_away is now known as siddharthv
pyon has joined #ocaml
sheijk has quit [Ping timeout: 245 seconds]
zpe has joined #ocaml
zpe has quit [Ping timeout: 256 seconds]
cespinoza has joined #ocaml
mcc has joined #ocaml
<mcc>
hi. so, i am looking over the section in the ocaml manual on the module system
<mcc>
i'm ... confused about a couple of things. if a file is included as a module, do i have to write the struct ... or module ... declarations within it? or does it just automatically become the right thing?
<mcc>
also, is the mli required or just a good idea or what?
keen___________ has joined #ocaml
samrat has joined #ocaml
keen__________ has quit [Ping timeout: 245 seconds]
<mcc>
also, as long as i'm asking questions like this... some of this sample code has a construct where "let () =" is alone on a line, followed by an indented block... what is the intent of the let () = line?
mawuli has quit [Ping timeout: 265 seconds]
Submarine has joined #ocaml
cespinoza has quit [Quit: Saliendo]
mawuli has joined #ocaml
sheijk has joined #ocaml
sheijk has quit [Ping timeout: 244 seconds]
hausdorff has quit [Remote host closed the connection]
hausdorff has joined #ocaml
zpe has joined #ocaml
hausdorff has quit [Ping timeout: 244 seconds]
zpe has quit [Ping timeout: 264 seconds]
twarog has joined #ocaml
hausdorff has joined #ocaml
twarog has quit [Ping timeout: 244 seconds]
<flux>
mcc, modules are either an expression, or a sequence of phrases
<flux>
phrases are top-level statements such as open XXX, module X = .., let a = b
<flux>
sequences of such fragments are separated with ;;
<flux>
so, basically, if your module is built only from one sequence of phrases, you never use the ;; to separate the fragments from each other
<flux>
(actually I think I said it a bit wrong, a phrase in itself is already a sequence of top-level statements)
<flux>
so let's say you wanted to define a function and then call it
<flux>
let foo () = Printf.printf "Hello world!\n"
<flux>
then the code following would need to be either let () = foo ()
<flux>
or ;;, a new line and foo ()
<flux>
people prefer not to use ;; as it makes it easier to move code around into modules (a module definition cannot have an embedded ;;)
psy_ has quit [Read error: Connection reset by peer]
<flux>
but, in particularly to someone new to the language, ;; could be useful in narrowing down syntax errors in the program, because such errors never 'travel' pass such a point
<flux>
s/pass/past/
sheijk has joined #ocaml
sheijk has quit [Ping timeout: 265 seconds]
zpe has joined #ocaml
zpe has quit [Ping timeout: 265 seconds]
MercurialAlchemi has joined #ocaml
<dwoos>
can anybody point me at an example of a udp server written using Async?
darkf has quit [Ping timeout: 244 seconds]
darkf has joined #ocaml
<dwoos>
and/or inform me of a better way to write an http server that does some number of udp sends+receives before responding and needs to handle many simultaneous connections?
<mcc>
flux: i see, thank you
utrulo has quit [K-Lined]
nojb has joined #ocaml
mort___ has joined #ocaml
psy_ has joined #ocaml
nojb has quit [Quit: nojb]
Unhammer has joined #ocaml
nojb has joined #ocaml
hyperboreean has quit [Ping timeout: 244 seconds]
hyperboreean has joined #ocaml
sheijk has joined #ocaml
zpe has joined #ocaml
nojb has quit [Quit: nojb]
nojb has joined #ocaml
bjorkintosh has quit [Ping timeout: 255 seconds]
sheijk has quit [Ping timeout: 264 seconds]
bjorkintosh has joined #ocaml
nojb has quit [Client Quit]
hhugo1 has joined #ocaml
nojb has joined #ocaml
arj has joined #ocaml
mcc has quit [Quit: This computer has gone to sleep]
nojb has quit [Quit: nojb]
larhat has quit [Quit: Leaving.]
struktured has quit [Ping timeout: 265 seconds]
oscar_toro has joined #ocaml
michipili has joined #ocaml
mort___ has quit [Quit: Leaving.]
sheijk has joined #ocaml
bjorkintosh has quit [Ping timeout: 245 seconds]
bjorkintosh has joined #ocaml
hhugo1 has quit [Quit: Leaving.]
tane has joined #ocaml
sheijk has quit [Ping timeout: 244 seconds]
demonimin has quit [Quit: No Ping reply in 180 seconds.]
demonimin has joined #ocaml
lordkryss has joined #ocaml
zpe has quit [Remote host closed the connection]
zpe has joined #ocaml
vogler has joined #ocaml
mawuli has quit [Ping timeout: 265 seconds]
zpe has quit [Ping timeout: 264 seconds]
nojb has joined #ocaml
WraithM has quit [Ping timeout: 258 seconds]
sheijk has joined #ocaml
oc has quit [Quit: Page closed]
AlexRussia has quit [Ping timeout: 265 seconds]
nojb has quit [Quit: nojb]
sheijk has quit [Ping timeout: 265 seconds]
arj has quit [Quit: Leaving.]
Submarine has quit [Quit: Leaving]
mawuli has joined #ocaml
govg has quit [Remote host closed the connection]
hausdorff has quit [Remote host closed the connection]
hausdorff has joined #ocaml
pyon has quit [Ping timeout: 245 seconds]
hausdorff has quit [Remote host closed the connection]
mort___ has joined #ocaml
hausdorff has joined #ocaml
hausdorff has quit [Remote host closed the connection]
zpe has joined #ocaml
sheijk has joined #ocaml
larhat has joined #ocaml
_andre has joined #ocaml
ggole has joined #ocaml
tane has quit [Quit: Verlassend]
dsheets has joined #ocaml
[mark] has joined #ocaml
alexherbo2 has joined #ocaml
<alexherbo2>
Hi
<alexherbo2>
I have troube to install ocam packages.
<SomeDamnBody>
should I fork, update, and do a pull request just for that?
jonludlam has joined #ocaml
pyon has joined #ocaml
ysz_ has joined #ocaml
<SomeDamnBody>
hey, opam also needs a note saying that base64 is a dependency of piqi
martintrojer has quit [Ping timeout: 272 seconds]
<Leonidas>
SomeDamnBody: yes, you can do a pull request for this
<SomeDamnBody>
ok
<SomeDamnBody>
cool
<Leonidas>
the advantage is that PRs get tested by CI
<SomeDamnBody>
cool
<SomeDamnBody>
I helped
<SomeDamnBody>
:)
<SomeDamnBody>
Leonidas, I just checked each of my pull requests before I sent them upstream... they compile on my machine.
<SomeDamnBody>
my changes are really minimal, one liners each
<SomeDamnBody>
document new package dependency, and add target in makefile
<Leonidas>
"they compile on my machine" is a weak benchmark, because the problem that piqi depends on base64 couldn't be spotted this way unless you first uninstall all other packages.
<Leonidas>
thats why the CI builders start from a clean slate
Thooms has joined #ocaml
martintrojer has joined #ocaml
jgjl has joined #ocaml
SomeDamnBody has quit [Ping timeout: 250 seconds]
siddharthv is now known as siddharthv_away
jgjl has quit [Quit: My MacBook Pro has gone to sleep. ZZZzzz…]
lordkryss has quit [Quit: Connection closed for inactivity]
jgjl has joined #ocaml
larhat1 has joined #ocaml
larhat has quit [Ping timeout: 265 seconds]
Hannibal_Smith has joined #ocaml
serge has quit [Remote host closed the connection]
serge has joined #ocaml
thomasga has quit [Quit: Leaving.]
lordkryss has joined #ocaml
thomasga has joined #ocaml
arj has joined #ocaml
AltGr has left #ocaml [#ocaml]
<hyperboreean>
merlin no longer works for me in emacs since I upgraded to 2.0 "The Merlin toolkit version 2.0, for Ocaml 4.01.". I get this error "merlin-make-point: Wrong type argument: number-or-marker-p, nil"
<hyperboreean>
did anyone come across this issue ? I can provide my emacs config if need be
oscar_toro has quit [Ping timeout: 256 seconds]
nojb has joined #ocaml
fraggle-boate has quit [Remote host closed the connection]
hyperboreean has quit [Quit: leaving]
hyperboreean has joined #ocaml
nicoo has quit [Ping timeout: 250 seconds]
samrat has quit [Quit: Computer has gone to sleep.]
Thooms has quit [Ping timeout: 256 seconds]
<MercurialAlchemi>
hyperboreean: it complained about pervasives when trying to use it with my stock ocaml compiler
<MercurialAlchemi>
works fine with switching the 4.2.0 compiler
nicoo has joined #ocaml
fraggle-boate has joined #ocaml
<hyperboreean>
MercurialAlchemi: yeah, maybe it's time to upgrade to 4.2.0, hopefully it will fix this issue
<companion_cube>
4.02.1 you mean
<troydm>
how can I defer the evaluation of expression with ocamlyacc
<flux>
how would that possibly work if the Printf.printf was executed before the incrementation is executed?
<flux>
so, it seems to me the only solution is indeed build an expression and then explicitly choose what to do with it.
<flux>
hmm, build a data structure that is
<nojb>
troydm: dypgen allows to have actions that are executed before the end of the rule (which will necessarily only be able to refer to the part of the rule that has already been parsed)
<nojb>
troydm: but it is probably a better idea to build an AST anyway
psy_ has quit [Ping timeout: 264 seconds]
samrat has joined #ocaml
thomasga has quit [Quit: Leaving.]
<troydm>
flux: nvm I've solved my problem by taking a different approach
<troydm>
now it's time to write a blog post about it :)
<dmbaturin>
troydm: What was the problem about?
<troydm>
dmbaturin: basicly I needed a way to track ast depth for asm code generation since I was pushing expressions on stack directly
<companion_cube>
does packing/unpacking first-class modules have a runtime cost? if yes, how costly?
<whitequark>
companion_cube: afaik, no
<whitequark>
they're just records
<companion_cube>
ok, so it's really just a type-level operation
<companion_cube>
cool.
sheijk has joined #ocaml
AlexRussia has joined #ocaml
<dsheets>
i think packing can have a cost if the signature doesn't match the struct... then you need to allocate a new record with appropriate pointers to the struct
<dsheets>
where by "match" i mean "identically match" and not "substructural equivalence" or whatever
oscar_toro has joined #ocaml
<companion_cube>
I'm more concerned about unpacking :)
<dsheets>
unpacking is syntactic
jgjl has quit [Quit: My MacBook Pro has gone to sleep. ZZZzzz…]
<companion_cube>
perfect, thanks
* companion_cube
wrapping stateful first-class modules into values
hhugo has quit [Quit: hhugo]
hhugo has joined #ocaml
serge has quit [Remote host closed the connection]
serge has joined #ocaml
Thooms has joined #ocaml
psy_ has joined #ocaml
Thooms has quit [Read error: Connection reset by peer]
shinnya has joined #ocaml
mort___ has quit [Ping timeout: 245 seconds]
jao has quit [Ping timeout: 255 seconds]
[mark] has quit [Quit: Leaving]
bytbox has quit [Remote host closed the connection]
jgjl has joined #ocaml
ousado has joined #ocaml
ousado has quit [Changing host]
ousado has joined #ocaml
ousado_ has joined #ocaml
ysz_ has quit [Remote host closed the connection]
twarog has joined #ocaml
dereinzige has joined #ocaml
dereinzige has quit [Client Quit]
thomasga has joined #ocaml
ousado has quit [Ping timeout: 265 seconds]
ousado_ is now known as ousado
ousado has quit [Changing host]
ousado has joined #ocaml
ysz_ has joined #ocaml
ysz_ has quit [Remote host closed the connection]
hugomg has joined #ocaml
ysz_ has joined #ocaml
bytbox has joined #ocaml
michipili has quit [Read error: Connection reset by peer]
bytbox has quit [Remote host closed the connection]
darkf has quit [Quit: Leaving]
twarog has quit [Ping timeout: 245 seconds]
badkins has joined #ocaml
ysz_ has quit [Remote host closed the connection]
shinnya has quit [Ping timeout: 260 seconds]
<companion_cube>
is there a clean way to have a Hash table that is weak in its keys?
abbe_ has joined #ocaml
__marius______ has quit [Ping timeout: 256 seconds]
__marius______ has joined #ocaml
abbe has quit [Ping timeout: 256 seconds]
abbe_ is now known as abbe
samrat has quit [Quit: Computer has gone to sleep.]
olasd has quit [Ping timeout: 256 seconds]
hhugo has quit [Ping timeout: 256 seconds]
fraggle-boate has quit [Ping timeout: 256 seconds]
rand000 has quit [Ping timeout: 256 seconds]
fraggle-boate has joined #ocaml
rand000 has joined #ocaml
arj has quit [Quit: Leaving.]
<MercurialAlchemi>
companion_cube: what would you use that for?
samrat has joined #ocaml
<companion_cube>
never mind, I need something more complex anyway
<companion_cube>
in general, to store additional data for keys, but only as long as they are alive?
<companion_cube>
that can be useful for caches
typedlambda has quit [Ping timeout: 250 seconds]
johnelse is now known as johnel_away
johnel_away has quit [Quit: Lost terminal]
johnelse has joined #ocaml
typedlambda has joined #ocaml
<MercurialAlchemi>
companion_cube: you could hash this data, then, and use the hash as key for a weak hash map, no?
yomimono has joined #ocaml
paddymahoney has joined #ocaml
<companion_cube>
the hash isn't enough, you always need to be able to compare for equality
<companion_cube>
in case of hash collision
<MercurialAlchemi>
depends on how much stuff you cache and how important it is
<MercurialAlchemi>
but if you store the additional data in the value, you can get your equality test
<MercurialAlchemi>
I'll grant you that it's a bit convoluted
<companion_cube>
then you need to be weak in the values
<MercurialAlchemi>
well, that was the idea, yes
<MercurialAlchemi>
that's often what you want for a cache...
govg has joined #ocaml
olasd has joined #ocaml
samrat has quit [Quit: Computer has gone to sleep.]
slash^ has joined #ocaml
<ggole>
companion_cube: isn't that what a weak hash table is?
<ggole>
(And the stdlib has one.)
<companion_cube>
the sdtlib has a weak set
<companion_cube>
hashset*
<ggole>
Right, but you can build a map out of such a set by using pairs
WhatElse has joined #ocaml
<ggole>
Hmm, although maybe only the pair would be weak.
<WhatElse>
hi guys, can you help me with this simple function: http://pastebin.com/cTN3jKVD ? I can’t understand why it doesn’t match that patter, I’ve written the parenthesis (s1,s2)
<companion_cube>
what's %! ?
<WhatElse>
to flush buffer
<companion_cube>
neat
<ggole>
The function is ok (except that print_newline; is probably a mistake). You might be calling it wrong.
<companion_cube>
WhatElse: this typechecks, it must be that the context gives it (string*string*_*_) list
<WhatElse>
companion_cube: yeah, that’s it, how stupid am I.. -_-
<WhatElse>
another question, that (string * string * ‘a * ‘b) is defined as a type in my application (t_trace) why doesn’t ocaml recognize it as t_trace?
<companion_cube>
both types will be the same to ocaml, but for printing it depends on its mood
<WhatElse>
lol, I don’t like that :P
<flux>
well, wrap it inside a sum type then :)
<mrvn>
ocaml doesn't make something a defined type just because it happens to match the definition. annotate it.
<WhatElse>
flux: what do you mean?
<WhatElse>
mrvn: ok, thank you
<flux>
type ('a, 'b) t = Type of (string * string * 'a * 'b)
<mrvn>
flux: That causes overhead though
<flux>
you can still pattern match it.. but it's a bit more verbose.
<flux>
mrvn, sad indeed, but who cares?-)
<mrvn>
writing: let foo (x : t_trace) = .... works without overhead
jgjl has quit [Quit: My MacBook Pro has gone to sleep. ZZZzzz…]
<flux>
but you can forget it and nobody complains.
<mrvn>
no harm done then
psy_ has quit [Read error: No route to host]
twarog has joined #ocaml
jgjl has joined #ocaml
yomimono has quit [Ping timeout: 264 seconds]
twarog has quit [Quit: leaving]
bytbox has joined #ocaml
manizzle has quit [Ping timeout: 264 seconds]
demonimin_ has joined #ocaml
demonimin has quit [Ping timeout: 260 seconds]
arj has joined #ocaml
psy_ has joined #ocaml
arj has quit [Ping timeout: 244 seconds]
zpe has quit [Remote host closed the connection]
mcc has joined #ocaml
jao has joined #ocaml
Hannibal_Smith has quit [Quit: Sto andando via]
jao has quit [Changing host]
jao has joined #ocaml
arj has joined #ocaml
<companion_cube>
if you remove the ( ) around the tuple, there is no more overhead, is there?
<dsheets>
companion_cube, what? no, the comma is the tuple constructor (and associative so multi-ary). parens are optional. [1,2,3; 4,5,6] = [(1,2,3); (4,5,6)]
arj has quit [Ping timeout: 250 seconds]
<mrvn>
The ( ) improve readability
<mrvn>
companion_cube: yes, should. 'type t = Type of a * b * c' and '(a * b * c)' is both a block with tag 0.
jonludlam has quit [Quit: Coyote finally caught me]
boogie has joined #ocaml
<Drup>
WhatElse: give the option "-short-paths " to the compiler
<Drup>
it will always print the shortest alias of the type
<WhatElse>
Drup: I’ll try thank you
<companion_cube>
mrvn: but in the first case you only have one block
mcclurmc has quit [Ping timeout: 255 seconds]
<dsheets>
companion_cube, ah, for constructors this is different
<companion_cube>
what I meant is that replacing (a * b) with type foo = Foo of 'a * 'b, is safer and has no overhead
<dsheets>
yes, i believe that is true
<dsheets>
i miss danmey
arj has joined #ocaml
<mrvn>
'type t = Type of a * b * c' and '(a * b * c)' is one block, 'type t = Type of (a * b * c)' is two blocks
<companion_cube>
exactly
<mrvn>
That's why I said it has overhead.
<companion_cube>
so just remove the ( ) in the last case and you're good to g
<companion_cube>
o
<dsheets>
sometimes you want the extra box so you can decouple the tag from the payload, though
<dsheets>
without allocating again
xavierm02 has joined #ocaml
<mrvn>
dsheets: Obj.magic
<dsheets>
ew
<mrvn>
ocaml could allow casting type t = Type of 'a * 'b to 'a * 'b
arj has quit [Ping timeout: 272 seconds]
serge has quit [Remote host closed the connection]
serge has joined #ocaml
paddymahoney has quit [Ping timeout: 265 seconds]
<dsheets>
that would be cool
<mcc>
Hey, so here is a question. I'm looking at the ocaml manual and reading on "functors" and objects/classes, and... I *think* i understand what functors do, esp because i have previous experience with smlnj, but
samrat has joined #ocaml
<mcc>
What is the reason why functors and objects/classes *both* exist, as two different things? Are functors for a sort of backward compatibility? Or is there some sense in which they serve different purposes and you need both?
<mrvn>
objects are OO, functors are more like templates
mcclurmc has joined #ocaml
<mcc>
hm, ok
arj has joined #ocaml
<mcc>
so like a module or struct parameterized by a type or something?
<mrvn>
objects allow inheritance and use dynamic dispatch of methods.
nojb has quit [Quit: nojb]
<mcc>
ok. can a functor create a class?
<mrvn>
sure. an object is just another type.
<whitequark>
the main benefit of objects is that they allow row polymorphism
<whitequark>
of classes, that they allow inheritance
<whitequark>
functors allow for neither
<dsheets>
erm, is it inheritance or open recursion?
<dsheets>
i.e. dynamic dispatch on self
<dsheets>
include is sort of a structural inheritance
arj has quit [Ping timeout: 265 seconds]
<Drup>
yeah, inheritance is usually not a problem to emulate with functors, it's just not pretty
<dsheets>
and destructive substitution lets you share types
<whitequark>
you're right
<Drup>
(open recursion is indeed only possible with objects, though)
* dsheets
has made module/functor/include/module type of monstrosities
<mrvn>
objects allow casting to the base class and putting them in the same list for example. With modules you can't.
<Drup>
dsheets: me too :D
<dsheets>
you could pack them into substructural packages, though...
<Drup>
mrvn: hum, you can ?
<mcc>
whitequark: ok. i guess what i'm trying to figure out is, my inclination is to use classes, because they are what i know, i am trying to figure out if i'm missing something if i ignore classes
<mcc>
SORRY i mean: if i'm missing something if i ignore functors
<Drup>
mcc: you're getting it wrong
<Drup>
don't use objects.
nop0x07bc has quit [Quit: WeeChat 1.0.1]
<Drup>
and yes, you'll miss something if you don't use functors.
<mrvn>
mcc: use objects when you want inheritance.
<mcc>
i usually want inheritance :)
<mrvn>
s/want/need/
<dsheets>
substructural module signatures work just as well for most uses of inheritance
<Drup>
mrvn: if he's use to the object paradigm, he'll want inheritence everywhere
<whitequark>
mcc: objects aren't used in OCaml in ways they're used in other languages that contain objects
<mcc>
drup: i am a she
<Drup>
mcc: oh, sorry.
AlexRussia has quit [Quit: WeeChat 1.1-dev]
<mcc>
drup: s'ok
<whitequark>
in fact, classes are used almost exclusively when you need open recursion, i.e. some kind of Visitor pattern
<whitequark>
and bare objects... usually I see them in various typing hacks
AlexRussia has joined #ocaml
<Drup>
or for widgets
<whitequark>
mcc: there is a certain temptation to design everything around objects, coming from an OO language
<whitequark>
I know, I had it
<whitequark>
I can say that it invariably leads to very bad design
<Drup>
objects are nice for widgets, that's almost the only good use case
<Drup>
anyway, yeah, mcc, for the meantime, don't use objects at all
* dmbaturin
was happy to find out there's life outside of the OOP paradigm
Hannibal_Smith has joined #ocaml
<Drup>
whitequark: funnily, when I started programming in Java, I did the opposite thing.
<Drup>
I knew ocaml quite well already, so I used generics, a lot.
<Drup>
:D
<dsheets>
i just wrote higher-order macros in C :-(
<dmbaturin>
Drup: Did you emulate ADTs too?
<Drup>
dmbaturin: I did, but for good reasons, I was building a compiler, you can't do that without some for of ADTs
<Drup>
form
AlexRussia has quit [Client Quit]
<dmbaturin>
True.
<Drup>
dmbaturin: also, the framework I was forced to use was generating the ADTs for me
<dmbaturin>
Which framework?
AlexRussia has joined #ocaml
<Drup>
XText
<mrvn>
Drup: I found that GUIs are the ideal example for OO. They just scream for it.
<mcc>
well, oo was sort of invented for it.
<Drup>
not really no
<mcc>
heh
arj has joined #ocaml
<mcc>
ok so i'm curious what drup means by "missing something with functors" and curious what whatequark means by "objects aren't used the way they're used in other languages"
<Drup>
dmbaturin: if you are willing, I can spend an hour on all the different way it sucks. :p
<dmbaturin>
Drup: "it" ::= <java|xtext|writing a compiler in java|life without ADT support|...> ? :)
<Drup>
huum
<Drup>
pretty much all of it, yes, but mostly xtext
<dsheets>
mcc, functors are used much more often than objects and are much easier to understand. Functors let you really take advantage of the module system in surprising parametric ways.
<Drup>
mcc: there are few things to note 1) OO in ocaml is not very idiomatic 2) the OO system is *weird* 3) objects are very inefficient
<whitequark>
I think that's, while correct, not the best way to put it
<mcc>
hmm, ok
<dsheets>
mcc, objects are used mostly for, as whitequark mentioned, their type-level names, row polymorphism (a type variable that means "and the other stuff"), and open recursion (late binding)
hausdorff has joined #ocaml
<whitequark>
OO design teaches you some things, like: separate concerns, make self-contained entities, and such
manizzle has joined #ocaml
<whitequark>
and in fact most of the principles of good design apply to OCaml code *without objects* just as wel
<whitequark>
well
<Drup>
whitequark: the issue is that modules do that better :>
<Drup>
(modules + interfaces + functors)
<whitequark>
I'm trying to not be inflammatory! but yeah, sorta
arj has quit [Ping timeout: 250 seconds]
<whitequark>
so a frequent design pattern in OCaml that you will see very often is
<whitequark>
a module with a type t and a bunch of functions operating on that type.
<mcc>
So i am going to be honest, i have read section 2.3 of the ocaml manual about functors multiple times and i am stull VERY CONFUSED ABOUT IT.
<whitequark>
which is *very* similar to an object, but without a lot of complex baggage that comes with objects
<whitequark>
like virtual dispatch or inheritance
<whitequark>
or subtyping or...
<Drup>
mcc: do you have a good mental image of what a module is ?
<mrvn>
mcc: a functor takes a interface implementation and produces a new module based on that interface.
roelof_ has joined #ocaml
<mcc>
drup: no, probably not. it seems like just kind of a namespace.
hausdorff has quit [Remote host closed the connection]
<mcc>
dsheets: oh, this looks much less confusing.
<mcc>
thanks :O
manizzle has quit [Remote host closed the connection]
<whitequark>
RWO is generally a great book
<mcc>
hm ok
<whitequark>
just ... don't use Core
<Drup>
ah ,yeah, dsheets is right, should have started by linking that :D
<mcc>
what is Core D:
<whitequark>
*cough* ActiveSupport of OCaml
<mcc>
the functor section of the manual is about one page long and very dense D:
<dmbaturin>
mcc: Core is a third-party standard library replacement.
<Drup>
the manual is very crude in general
<Drup>
it's a good document when you know the language and are looking for something
<Drup>
but not a very good tutorial
<whitequark>
Core is a very extensive standard library replacement, but it's very very monolithic and heavyweight
<Drup>
RWO does a much better job at that
<mcc>
okay so the reasons i *actually* use classes/objects are mostly to do with code clarity and ease of construction. i want namespacing, if i have a bunch of functions all over the place in one namespace i get confused. i like inheritance because i like building things up one function at a time.
<mrvn>
mcc: moudles can do that
<whitequark>
namespacing in OCaml is provided by modules
<whitequark>
building things up one function at a time could also be done with modules, though it would result in a slightly unusual design
<whitequark>
totally possible, though
<mcc>
like, if i have a data object, i have a data-object-representing-a-number, and i have a data-object-representing-an-int and a data-object-representing-a-float, it seems natural to me if there's some function which is relevant to only the numbers i would want to be able to just put it with the numbers
manizzle has joined #ocaml
<whitequark>
oh
<ggole>
roelof_: the error message should contain a marker that points to the problematic bit
<whitequark>
mcc: that is usually done with phantom types.
<mcc>
that is just what seems *convenient*. obviously there are other ways to do that
<mcc>
hm ok
<mrvn>
mcc: You might want objects when you need a list of data-objects of different sub types.
<whitequark>
it's much more convenient than objects, though it can seem odd at first
WhatElse has quit [Quit: WhatElse]
<whitequark>
Drup: do you know a good intro to phantom types?
<mcc>
(another thing is that my goal here is i am actually implementing an interpreter for an object oriented language, so it might make sense if i have the interpreter's data types to some extent mirroring the language's inheritance tree, but that is not a compelling reaosn by itself)
<Drup>
whitequark: I don't
<roelof_>
ggole : yep the problematic bit is the in acc 0 part as I said in my questions
<mcc>
mrvn: heterogenous lists you mean.
<Drup>
but that would be *very* interesting to write
<mrvn>
mcc: yes.
WhatElse has joined #ocaml
<mrvn>
mcc: you can probably translate the language into ocaml and then just run it in the toplevel.
<mcc>
i'm just trying to describe-- these are things that objects usually do naturally, which is why i am starting with "i'll use that", but i understand i could get them other ways which might be more apt to this language
<Drup>
mcc: that's even a very bad reason :)
<mcc>
mrvn: it's a possibility.
<Drup>
mcc: by pure curiosity, which language do you know ?
jgjl has quit [Quit: My MacBook Pro has gone to sleep. ZZZzzz…]
xavierm02 has quit [Quit: Page closed]
<ggole>
roelof_: you're trying to apply acc, but it isn't bound at that point. It's local the the nested function.
<ggole>
*local to
<mcc>
drup: erm... a bunch of them?? i guess the ones i use most lately are c++/objc, python and lua
<Drup>
ok
<mcc>
what is it that makes objects inefficient in ocaml, exactly? is there something about them which is opaque to the type system, or ... something like this?
<Drup>
just the fact it's dynamic dispatch
<mrvn>
python sucks for long term developement imho. If you change a variable name or api or so then you get lots of hidden bugs unless you have total test coverage. And how do you get that for a gui?
arj has joined #ocaml
<whitequark>
they're not less efficient than, say, in python
<Drup>
mcc: it's just far less efficient than normal function calls
<roelof_>
ggole: that is what i trying to do. The first time acc must be 0 and list2 must be list2. They both are needed only in the nested function
<whitequark>
^
<mcc>
mrvn: yes, that's why i'm trying to write a new python-y language instead of just using python :P
<Drup>
ahah :D
<Drup>
that's gonna end well :p
<mcc>
why can't the world just give me typed lua.
<Drup>
it's called julia
<Drup>
it exists already
<mcc>
julia is *very* interesting.
<mcc>
it does not seem very deployable however.
<mrvn>
mcc: the good thing about python are all the extra modules. You and what army of programmes will rewrite them all?
<dsheets>
whitequark, i have a non-capturing buffer-accepting c function... what is the easy way to pass it an ocaml string?
<mcc>
also it doesn't work on my operating system. but that is going to change in a couple months :P
<Drup>
ah, that's another issue :)
<mcc>
mrvn: well, i'm targeting game programmers. so a lot of those modules are not relevant.
<mrvn>
dsheets: with or without runtime lock?
<mcc>
mrvn: however my short version is "interact with the haxe compiler, transpile to python, and then use the *actual* python modules" :P
<ggole>
roelof_: I imagine you want to pass those values to the nested function
<dsheets>
mrvn, with lock, just straight ctypes
<Drup>
mcc: oh, Haxe, hence OCaml, ok :)
<mcc>
exactly
<whitequark>
dsheets: ocaml_string, surprisingly
<Drup>
mcc: Can you elaborate on the data-as-int and data-as-float example a bit ?
<whitequark>
dsheets: assuming you mean ctypes
jwatzman|work has joined #ocaml
<roelof_>
ggole: yep, Im trying to make a hidden function that counts the list
<Drup>
I was going to write an ocaml version, but I would like more details
<dsheets>
whitequark, yes, i have one from ocaml_string_start but it's an `OCaml string, not a `C string and my interface... never mind
<hugomg>
@mcc: theres a phd in Puc Rio working on Typed Lua. Have you heard of it?
<mcc>
ok so just to be clear. and probably i should read this in detail but i'm looking for a 10,000 foot detail. in some languages, notably c++, dynamic dispatch can in some cases be compiled out. is ocaml not one of those languages?
arj has quit [Ping timeout: 255 seconds]
<Drup>
yeah
<mcc>
hugomg: yes, i've seen their paper, it's very compelling. do you know if they are working on an implementation?
<ggole>
roelof_: you've defined the function, but you aren't calling it
<Drup>
the ocaml compiler doesn't optimize a lot
<mrvn>
mcc: ocaml doesn't do that at all.
<mcc>
huh ok
<whitequark>
mostly because no one really uses objects much
<whitequark>
and certainly not in critical paths
<hugomg>
I think andré has an implementation on his github. Its very alpha though :/
<mcc>
ok, i see.
<mrvn>
Do object method for know objects even get inlined?
<mcc>
then why it is in your name? so strange.
<mcc>
(not your language specifically, just the way language names seem to work out...)
<whitequark>
it's weird in my opinion too
<Drup>
accident ? :D
<dsheets>
objects are the Next Big Thing
<mrvn>
dsheets: nah, thats first class modules
<whitequark>
it's really not a very important part of the language
<Drup>
except for type trickery
<roelof_>
ggole : oke, so calling it on x:xs is not enough ?
<whitequark>
in fact, I've worked with OCaml for more than a year now, I don't think I ever used objects
<mcc>
drup: by the way, if my impression is that Julia is going to be a big pain if my goal is to have (preferably small) redistributable binaries that run on many different systems. do you think my impression is incorrect?
<Drup>
whitequark: even for utop/lambda-term ?
<mrvn>
whitequark: so you never written widgets for a gui then
<whitequark>
Drup: mrvn: yes, and I didn't really touch that code
<Drup>
mcc: considering it uses llvm as a JIT, you are probably right.
<mcc>
drup: ... that means a redistributable that embeds its jit would be about 200 MB, right?
<dsheets>
first class modules? sounds like the 70s... i'll take my factory visitor manager and see you in the future!!
<mrvn>
dsheets: it means that you can pass modules as arguments to functions or return them.
<mcc>
hugomg: oh! i hadn't seen that. that's exciting
<mcc>
whitequark: hm. better than unity, worse than luajit...
<mrvn>
dsheets: you don't have to manually build a record with function callbacks yourself.
<Drup>
my impression was that everything is better than unity :]
<dsheets>
mrvn, but are these "first class modules" enterprise ready?
<whitequark>
mcc: LLVM wasn't really designed to be a JIT
<whitequark>
it slowly became a better JIT, but it's still not the main use case
<whitequark>
and it shows
misv has quit [Ping timeout: 240 seconds]
<ggole>
roelof_: no
<mrvn>
dsheets: only if you work at janestreet
<Drup>
:D
<mcc>
whitequark: yeah, i think you've mentioned that
<Drup>
Do they use functors ?
<roelof_>
ggole: then back to the books and trying to find out what to change to make this work
<roelof_>
thanks for the help so far
<Drup>
I think they eliminated most functors in the stdlib, and I don't recall any others
misv has joined #ocaml
<Drup>
(in Core)
<ggole>
roelof_: you need to call your nested function, it's really very simple.
MercurialAlchemi has quit [Remote host closed the connection]
<dsheets>
they use tons of module inclusion
<Drup>
yeah
<Drup>
that's terrifying
<Drup>
it's like "how to reproduce indirection spaghetti from OO in OCaml"
<dsheets>
it's agile
MercurialAlchemi has joined #ocaml
<Drup>
(and badly supported by ocamldoc)
* dsheets
looks at his watch and wanders off to hack on a new documentation generator
<Drup>
:D
<ggole>
It's a bit reminiscent of inheritance
<Drup>
dsheets: do you have an ETA for it ? :p
hausdorff has joined #ocaml
arj has joined #ocaml
<Drup>
you need to do proper risk assessment and deadline planning.
<roelof_>
ggole: Im still looking in the first chapters of realworldOcaml for the answeer
<dsheets>
Drup, there are a lot of components. we've been having meetings and keeping track of progress extensively. it sucks.
<roelof_>
but first dinner :)
<dsheets>
also, I'm not the PM thank FSM
hugomg has quit [Ping timeout: 265 seconds]
hausdorff has quit [Remote host closed the connection]
<Drup>
:D
arj has quit [Ping timeout: 244 seconds]
<ggole>
Finite state machines won't save you.
WraithM has joined #ocaml
hausdorff has joined #ocaml
<roelof_>
ggole: thanks and have a good evening . Byee everyone
* mcc
is heading out, thank you all so much for the help!
roelof_ has quit [Quit: Page closed]
hausdorff has quit [Remote host closed the connection]
manizzle has quit [Ping timeout: 244 seconds]
Submarine has joined #ocaml
arj has joined #ocaml
mcc has quit [Quit: This computer has gone to sleep]
<Drup>
whitequark: do you have a good idea for a phantom type tutorial ?
hugomg has joined #ocaml
<whitequark>
Drup: except for "phantom types yay", no
arj has quit [Ping timeout: 250 seconds]
<Drup>
x)
thomasga has quit [Quit: Leaving.]
<dmbaturin>
Drup: There was something on janestreet blog. I wouldn't call it good, I still don't fully understand how to use them, but it can be just me. :)
<gdsfh1>
Drup: "objects are very inefficient" -- have you ever seen a real case (not microbenchmark) where profiler tells "more than 1% of program running time is spent on accessing object's methods"?
<Drup>
gdsfh1: no, because nobody is using objects in thigh loops in OCaml.
lordkryss has quit [Quit: Connection closed for inactivity]
<dmbaturin>
Drup: In what loops?
<companion_cube>
so you don't know whether they are this slow
kakadu has quit [Quit: Page closed]
<Drup>
dmbaturin: the one created by tail-recursion, of course :]
badkins has quit [Ping timeout: 264 seconds]
sheijk has quit [Ping timeout: 265 seconds]
<whitequark>
Drup: "thigh loops"
manizzle has joined #ocaml
<Drup>
oh, pffr x)
<gdsfh1>
btw many people put many different objects into them.
<whitequark>
I don't want to know
jwatzman|work has quit [Quit: jwatzman|work]
thomasga has joined #ocaml
arj has joined #ocaml
jwatzman|work has joined #ocaml
arj has quit [Ping timeout: 240 seconds]
Hannibal_Smith has quit [Quit: Sto andando via]
<dmbaturin>
What was (or could be) the motivation behind not having first class constructors?
dsheets has quit [Ping timeout: 260 seconds]
<whitequark>
I don't think there is actually something that prevents having them
ontologiae has joined #ocaml
<whitequark>
I mean, the compiler can just generate a function alright if a constructor is partially applied.
BitPuffin has joined #ocaml
MrScout has joined #ocaml
<mrvn>
dmbaturin: never change a running system
thomasga has quit [Quit: Leaving.]
hausdorff has joined #ocaml
<dmbaturin>
mrvn: How would first class constructors change a running system? Which system?
<mrvn>
dmbaturin: it needs changes in the compiler.
<Drup>
mrvn: don't even need to change the running system
arj has joined #ocaml
<mrvn>
new code, new bugs. That's about the only argument I can think of against first class constructors.
<dmbaturin>
Well, sure. I mean, why language designers might have chosen not to include it in the language.
<Drup>
dmbaturin: I have my own answer, but it contains words and judgments that are not appropriates for this channel. :)
<mrvn>
dmbaturin: they didn't think of it
<companion_cube>
they could have done so many things
<companion_cube>
let's just be happy that ocaml is this good already
hausdorff has quit [Remote host closed the connection]
hausdorff has joined #ocaml
arj has joined #ocaml
tane has joined #ocaml
arj has quit [Read error: Connection reset by peer]
hausdorff has quit [Remote host closed the connection]
<dmbaturin>
gdsfh1: Oh, that explains.
<Drup>
really ? for me it's mostly bad reasons ...
badkins has joined #ocaml
MrScout has quit [Remote host closed the connection]
<dmbaturin>
Drup: Good or bad, it shows what kind of motivation X. Leroy had for it. :)
MrScout has joined #ocaml
larhat1 has quit [Quit: Leaving.]
hausdorff has joined #ocaml
ggole has quit []
MrScout has quit [Ping timeout: 258 seconds]
bytbox has quit [Remote host closed the connection]
MrScout has joined #ocaml
bytbox has joined #ocaml
samrat has quit [Quit: Computer has gone to sleep.]
<nlucaroni>
that would be nice to have.
q66 has joined #ocaml
<whitequark>
didn't r syntax introduce this ability?
<whitequark>
revised.
wwilly has joined #ocaml
hausdorff has quit [Remote host closed the connection]
thomasga has joined #ocaml
<gdsfh1>
as a fan of revised syntax i can say: no, it didn't. It has "Constr arg1 .. argN" instead of ugly "Constr (arg1, .., argN)", but that's another thing.
<Drup>
a fan of the revised syntax, I can't say I knew this species existed :D
kakadu has joined #ocaml
WhatElse has quit [Quit: WhatElse]
_andre has quit [Quit: leaving]
hausdorff has joined #ocaml
hausdorff has quit [Remote host closed the connection]
Anarchos has joined #ocaml
hausdorff has joined #ocaml
hausdorff has quit [Remote host closed the connection]
govg has quit [Remote host closed the connection]
paddymahoney has joined #ocaml
govg has joined #ocaml
BitPuffin has quit [Quit: See you on the dark side of the moon!]
<dmbaturin>
What is 'revised syntax'?
<nlucaroni>
it's for camlp4/5, probably not worth your time.
<gdsfh1>
revised syntax is a more logical and safe ocaml syntax.
<companion_cube>
it has ugly points though, like lists
<Drup>
and with as many quirks, and basically used by nobody except camlp4 definition files
paddymahoney has quit [Ping timeout: 250 seconds]
slash^ has quit [Read error: Connection reset by peer]
martintrojer has quit [Ping timeout: 272 seconds]
slash^ has joined #ocaml
larhat has joined #ocaml
martintrojer has joined #ocaml
<gdsfh1>
i don't think that revised syntax for lists is ugly. brackets denote "it's a list", then either ";" between items or "::" as cons. simple and logical.
<mrvn>
so [ 1 :: 2 ; 3 ]?
<gdsfh1>
mrvn: [1; 2; 3]
slash^ has quit [Read error: Connection reset by peer]
hausdorff has joined #ocaml
manud has joined #ocaml
yomimono has joined #ocaml
<dmbaturin>
nlucaroni: I'm going to learn how to use camlp4 some day.
<Drup>
I'm not sure you really need to now
<dmbaturin>
Technically, I didn't need to learn ocaml either. :)
<Drup>
what I mean is that 1) it's an horrible undocumented mess 2) for most things, ppx can do it
<dmbaturin>
Oh. I still haven't looked into ppx.
<whitequark>
camlp4 needs to be burned.
<Drup>
I like your delicacy, whitequark :p
<nlucaroni>
yeah, ppx is what you'll most likely learn.
<dmbaturin>
So I should burn it before reading? :)
<whitequark>
yes.
hausdorff has quit [Remote host closed the connection]
<whitequark>
then, consider reading about something useful instead.
<companion_cube>
like camlp5
<whitequark>
like The Onion
<nlucaroni>
ha
<whitequark>
more useful than camlp4.
hausdorff has joined #ocaml
<dmbaturin>
Is camlp5 documented?
<whitequark>
of course not
<companion_cube>
dmbaturin: I was joking
<dmbaturin>
That's what I thought.
<nlucaroni>
doesn't it have more documentation than camlp4?
hausdorff has quit [Remote host closed the connection]
claudiuc has joined #ocaml
claudiuc has quit [Remote host closed the connection]
claudiuc has joined #ocaml
hausdorff has joined #ocaml
MrScout has quit [Remote host closed the connection]
MrScout has joined #ocaml
govg has quit [Remote host closed the connection]
MrScout has quit [Ping timeout: 264 seconds]
marvin-hh has quit [Max SendQ exceeded]
marvin-hh has joined #ocaml
rand000 has quit [Quit: leaving]
marvin-hh has quit [Max SendQ exceeded]
marvin-hh has joined #ocaml
Quintasan has joined #ocaml
ontologiae has quit [Ping timeout: 250 seconds]
<Quintasan>
Hi, I'm not sure if this is the correct place to ask but can you somehow make emacs (using tuareg) to work with read_int?
nojb has joined #ocaml
MrScout has joined #ocaml
hausdorff has quit [Remote host closed the connection]
Thooms has joined #ocaml
Anarchos has quit [Quit: Vision[0.9.7-H-20140108]: i've been blurred!]
ontologiae has joined #ocaml
badkins has quit [Remote host closed the connection]
badkins has joined #ocaml
zpe has joined #ocaml
badkins has quit [Read error: Connection reset by peer]
tratrala has joined #ocaml
wwilly has quit [Quit: This computer has gone to sleep]
Submarine has quit [Ping timeout: 250 seconds]
badon_ has joined #ocaml
badon has quit [Disconnected by services]
tane has quit [Quit: Verlassend]
shinnya has joined #ocaml
badon_ is now known as badon
Submarine has joined #ocaml
jave has quit [Ping timeout: 245 seconds]
jave has joined #ocaml
MercurialAlchemi has quit [Ping timeout: 255 seconds]
jwatzman|work has quit [Quit: jwatzman|work]
jwatzman|work has joined #ocaml
hausdorff has joined #ocaml
oscar_toro has quit [Ping timeout: 260 seconds]
jao has quit [Ping timeout: 250 seconds]
hhugo has joined #ocaml
pdewacht has joined #ocaml
hugomg has quit [Quit: Leaving]
manud has quit [Quit: Be back later ...]
tratrala has quit [Ping timeout: 255 seconds]
tratrala has joined #ocaml
manud has joined #ocaml
tratrala has quit [K-Lined]
badon has quit [Ping timeout: 264 seconds]
badon_ has joined #ocaml
badon_ is now known as badon
hhugo has quit [Quit: Leaving.]
nojb has quit [Quit: nojb]
badkins has joined #ocaml
Thooms has quit [Quit: WeeChat 1.0.1]
lordkryss has quit [Quit: Connection closed for inactivity]
zpe has quit [Remote host closed the connection]
hausdorff has quit [Remote host closed the connection]