<alephlambda>
Hi. I'm using classes in OCaml for the first time. I was wondering if there's a way to create a class whose val has type 'a (sort of like void* in C)?
jonludlam has quit [Remote host closed the connection]
<smondet>
alephlambda: you need to parametrize the type 'a
<smondet>
class ['a] c (x: 'a) = object val v = x end;;
nikki93 has quit [Remote host closed the connection]
Don_Pellegrino has quit [Quit: Konversation terminated!]
Don_Pellegrino has joined #ocaml
<alephlambda>
smondet: Thanks! Could you explain a little more about the [a'] syntax
NoNNaN has quit [Remote host closed the connection]
Don_Pellegrino has quit [Quit: Konversation terminated!]
NoNNaN has joined #ocaml
Don_Pellegrino has joined #ocaml
ygrek_ has joined #ocaml
jwatzman|work has quit [Quit: jwatzman|work]
nikki93 has joined #ocaml
alephlambda has quit [Quit: leaving]
tobiasBora has quit [Quit: Konversation terminated!]
lostcuaz has joined #ocaml
dsheets has quit [Ping timeout: 264 seconds]
malo has quit [Quit: Leaving]
jao has joined #ocaml
jao has quit [Changing host]
jao has joined #ocaml
zarul has joined #ocaml
aurynj has joined #ocaml
zarul has quit [Read error: Connection reset by peer]
dant3 has quit [Quit: I'm using a Free IRC Bouncer from BNC4FREE - http://bnc4free.com/]
talzeus has quit [Read error: Connection reset by peer]
<gasche>
it looks like an integration of existing things (eg. emacs+ocamldebug always existed), which is good
<gasche>
I wonder how much work would be require to integrate with Merlin, which is really the tool you'd like such an environment to use
<elfring>
Are you eventually interested in improvements for build specificatiions with software like "autotools" and "automake"?
<gasche>
( def-lkb asmanur , any ideas for how to integrate bits of it to improve merlin-emacs, or in the other direction how to help him integrate with merlin ?)
freling has quit [Quit: Leaving.]
<gasche>
elfring: I don't know what you call a "build specification", and never used automake
freling has joined #ocaml
ollehar has joined #ocaml
<elfring>
I would categorise a source file like "configure.ac" as a part of a software build specification. Do you think about corresponding adjustments in different ways?
<gasche>
I have the luck of never having to deal with autotools personally, so I don't have much to comment about
<asmanur>
gasche: the thing is he reimplements part of what merlin provides
<asmanur>
(or uses default solution I guess)
mrvn has quit [Ping timeout: 264 seconds]
dsheets has joined #ocaml
<elfring>
I hope to find more software developers who dare to fiddle with the combination "OCaml" and "autotools/automake".
<flux>
I think autotools are not universally loved by people. and possibly less so by people who don't need to deal with C (or C++).
<Drup>
elfring: I hope you strop trying to adapt C++ solution to OCaml, and try to learn ocaml first.
<Drup>
stop*
<elfring>
I find that the selection of a software build system can be performed in a way which is independent to some degree from a favourite programming language, can't it?
<Drup>
which language did you used before ?
<Drup>
in theory, it's true
<Drup>
in practice, not that much
<Drup>
because each language community pick a tool and specialize it for their own purposes.
<elfring>
Are you interested to improve the build practice for a software like "Coccinelle" (program "spatch")?
mrvn has joined #ocaml
<Drup>
I don't work on software that I don't use, so no :)
<gasche>
elfring: re. your "external dependencies in coccinelle OCaml scripts", I'll try to discuss that with Julia next time I meet her
<elfring>
gasche: Another interesting feedback. Will the chances also increase to fix Coccinelle's current build script "configure.ac"?
dsheets has quit [Ping timeout: 252 seconds]
<gasche>
I don't know about configure.ac and what problems you have with it
<gasche>
I would recommend that you send a patch if there is a fix to be made
venk has quit [Read error: Connection reset by peer]
venk has joined #ocaml
<elfring>
gasche: Would you like at one of the discussions like "1.0.0-rc16: Further fine-tuning for the build system?" from the previous year?
maattdd has quit [Ping timeout: 252 seconds]
rand000 has quit [Ping timeout: 246 seconds]
aurynj has joined #ocaml
maattdd has joined #ocaml
claudiuc has joined #ocaml
claudiuc_ has quit [Ping timeout: 252 seconds]
eni has quit [Ping timeout: 265 seconds]
_andre has joined #ocaml
AltGr has left #ocaml []
iZsh has joined #ocaml
ygrek has quit [Ping timeout: 252 seconds]
thomasga has joined #ocaml
eni has joined #ocaml
elfring has quit [Quit: Konversation terminated!]
jonludlam has joined #ocaml
siddharthv is now known as siddharthv_away
dsheets has joined #ocaml
maattdd has quit [Ping timeout: 240 seconds]
avsm has joined #ocaml
AltGr has joined #ocaml
aurynj has quit [Ping timeout: 252 seconds]
dsheets has quit [Ping timeout: 264 seconds]
talzeus_ has quit [Remote host closed the connection]
maattdd has joined #ocaml
skchrko has joined #ocaml
thomasga has quit [Quit: Leaving.]
maattdd has quit [Ping timeout: 265 seconds]
patronus_ has joined #ocaml
yroeht2 has quit [Read error: Operation timed out]
yroeht2 has joined #ocaml
adrien has quit [Read error: Operation timed out]
adrien has joined #ocaml
asmanur has quit [Read error: Operation timed out]
rixed_ has quit [Read error: Operation timed out]
rixed has joined #ocaml
asmanur has joined #ocaml
patronus has quit [Ping timeout: 252 seconds]
yacks has quit [Ping timeout: 252 seconds]
avsm has quit [Quit: Leaving.]
eni has quit [Ping timeout: 265 seconds]
maattdd has joined #ocaml
demonimin has quit [Quit: No Ping reply in 180 seconds.]
demonimin has joined #ocaml
thomasga has joined #ocaml
thomasga has quit [Client Quit]
tlockney_away is now known as tlockney
thomasga has joined #ocaml
maattdd has quit [Ping timeout: 264 seconds]
eni has joined #ocaml
maattdd has joined #ocaml
ygrek has joined #ocaml
mika1 has quit [Quit: Leaving.]
tlockney is now known as tlockney_away
lostcuaz has joined #ocaml
lostcuaz has quit [Client Quit]
divyanshu has quit [Quit: Computer has gone to sleep.]
mika1 has joined #ocaml
avsm has joined #ocaml
avsm has quit [Client Quit]
talzeus has joined #ocaml
talzeus has quit [Remote host closed the connection]
talzeus has joined #ocaml
darkf has quit [Quit: Leaving]
yacks has joined #ocaml
tlockney_away is now known as tlockney
shinnya has joined #ocaml
dsheets has joined #ocaml
dsheets_ has joined #ocaml
dsheets__ has joined #ocaml
dsheets_ has quit [Ping timeout: 246 seconds]
dsheets has quit [Ping timeout: 246 seconds]
rand000 has joined #ocaml
dsheets__ has quit [Ping timeout: 252 seconds]
divyanshu has joined #ocaml
elfring has joined #ocaml
bam365 has joined #ocaml
tlockney is now known as tlockney_away
amirmc has joined #ocaml
rand000 has quit [Ping timeout: 264 seconds]
rand000 has joined #ocaml
petterw has quit [Read error: Operation timed out]
<def-lkb>
gasche: 5 people for paparazzi is ok… I would first remove anybody related to HTML5 or JS :P
<gasche>
hehe
<gasche>
OCaml was mentioned first
<gasche>
but then there are "Historical" slides
<thomasga>
def-lkb: does php count as well ?
ollehar1 has quit [Ping timeout: 245 seconds]
<gasche>
with Eiffel and Prolog in it
<thomasga>
(no mention of facebook french engineers for instance)
<def-lkb>
thomasga: hmm… Then, may I suggest whitelisting rather than blacklisting? :p
<thomasga>
:-)
<companion_cube>
lambda-prolog, even
<companion_cube>
which is nice
<thomasga>
(and no mention of opam at all)
<companion_cube>
:DD
<thomasga>
:p
<def-lkb>
:)
aurynj has joined #ocaml
tlockney_away is now known as tlockney
avsm has joined #ocaml
ikaros has quit [Quit: Ex-Chat]
dsheets__ has joined #ocaml
<elfring>
I would like to try out the module "Omap" (which was developed by Jacques Garrigue in the year 2002). How should I create new objects by the provided interfaces?
shinnya has quit [Ping timeout: 252 seconds]
divyanshu has quit [Quit: Computer has gone to sleep.]
mreca has joined #ocaml
<companion_cube>
elfring: you have to use the object part of OCaml, in this case it's probably new Omap.c list_bindings
<companion_cube>
are you sure you need this, though
<companion_cube>
?
<elfring>
I find the approach by Jacques Garrigue very promising.
divyanshu has joined #ocaml
<companion_cube>
only if you need objects
<elfring>
But ... # let x = new c();;
<elfring>
Error: This expression has type unit but an expression was expected of type ('a * 'b) list
<companion_cube>
yes, you need to give it a list of arguments
rand000 has quit [Ping timeout: 252 seconds]
<elfring>
Do I stumble on an OCaml beginner's difficulties with object creation from parameterised classes?
<thomasga>
#let x = new c [];;
<thomasga>
just read the error message you just copy-pasted :-)
<adrien>
elfring: objects are an _advanced_ topic in OCaml
<adrien>
elfring: you should stay away from them for a while
<elfring>
thomasga: Thanks for your hint. I'm sorry that I became not familiar enough with the shown star notation so far. How should I recognise the required arguments for a parameterised class?
mort___ has joined #ocaml
<thomasga>
elfring: not sure to understand what you mean. But as adrien pointed out, you maybe should start by learning the basics of the language and its type system before trying to use objects
<thomasga>
but I guess that `let t = c [ ("foo", 1); ("bar", 2) ]` should work
<thomasga>
sorry `let t = new c [ ("foo", 1); ("bar", 2) ]`
<thomasga>
anyway, not sure why you want to use objects there …
<elfring>
I feel comfortable with some OCaml basics in the meantime. I like the advanced technique "object-oriented software development".
eni has quit [Quit: Leaving]
<ggole>
If you don't know what the notation 'a * 'b refers to, it seems there are some basics left to cover.
<ggole>
Of course, please yourself.
WraithM has joined #ocaml
seanmcl has joined #ocaml
<elfring>
ggole: I hope that my understanding for such basic "left overs" will improve in the near future ...
<elfring>
thomsage: Does a module like "Omap" provide technical properties which might become more appealing than the run time behaviour of the module "Hashtbl" from the standard library for some use cases?
<thomasga>
no
<ousado>
elfring: what?
seanmcl has quit [Quit: seanmcl]
lostcuaz has joined #ocaml
<elfring>
Do you find anything "wrong" with a module like "Omap"?
<thomasga>
it use objects
<thomasga>
(I don't really understand why you don't want to listen to the other people , but they are right :p)
<whitequark>
it can be hard to get rid of "everything should be an object" mindset
<whitequark>
for me, key was understanding that properties provided by OO (e.g. encapsulation) aren't intrinsically tied to it
<elfring>
That is fine for me. It seems that the module "Omap" supports also two programming techniques:
<elfring>
- Algorithms for immutable data strcutures
<elfring>
- Modifiable objects with method calls
<ggole>
Mmm, sums and abstract types get you quite a long way
<Drup>
elfring: I'm going to repeat myself : "(11:22:10) Drup: elfring: I hope you stop trying to adapt C++ solution to OCaml, and try to learn ocaml first."
skchrko has quit [Remote host closed the connection]
mort___ has quit [Quit: Leaving.]
jwatzman|work has joined #ocaml
mort___ has joined #ocaml
madroach has joined #ocaml
ocp has joined #ocaml
lordkryss_ has joined #ocaml
<gasche>
thomasga: have you heard about Bundler (a package manager for Ruby, iirc.)? Rust people have decided to rely on the ideas behind it for their (new) package manager
<thomasga>
"We started work 10 days ago, and we already have a primitive "cargo" compiling one of our libraries based on its Cargo manifest [..]" <- who said it was hard to write a package manager ?
ollehar has quit [Ping timeout: 240 seconds]
<adrien_oww>
krkrkr
amirmc has quit [Quit: Leaving.]
Kakadu has quit [Quit: Page closed]
mort___ has quit [Ping timeout: 246 seconds]
<avsm>
gasche: yeah, ive used bundler. It's not got a constraint solver, so there's that...
<avsm>
with the compiler-as-a-package opam patch, we could actually handle rust packages out of the box, including tracking upstream language changes...
<avsm>
one thing i'd quite like in OPAM is the 'bundle install' feature. That queries the current directory and satisfies dependencies if it finds a ruby package
<avsm>
so our equivalent would be to find an `opam` file in a working tree and attempt to install it
thomasga has quit [Quit: Leaving.]
S11001001 has joined #ocaml
S11001001 has quit [Changing host]
S11001001 has joined #ocaml
<dsheets__>
avsm, we also need to be able to generate opam files with specific version dependencies from a working config?
<avsm>
yeah, but that's a less common case than just wanting to install something i imagine
Thooms has quit [Quit: WeeChat 0.3.8]
<dsheets__>
true... also not clear if switches are the right abstraction in that kind of world
thomasga has joined #ocaml
zpe has quit [Remote host closed the connection]
claudiuc_ has joined #ocaml
zpe has joined #ocaml
segmond has quit [Ping timeout: 268 seconds]
claudiuc has quit [Ping timeout: 265 seconds]
zpe has quit [Ping timeout: 252 seconds]
rand000 has joined #ocaml
Kakadu has joined #ocaml
nikki93 has joined #ocaml
thomasga has quit [Read error: Operation timed out]
jonludlam has quit [Remote host closed the connection]
dsheets__ has quit [Ping timeout: 264 seconds]
q66 has joined #ocaml
<companion_cube>
avsm: is it normal, in the PR for the unecessary boxing, that "movq $1, %rax" appears twice in a row?
<companion_cube>
isn't it inefficient?
<companion_cube>
(could also ask gasche indeed)
michel_mno is now known as michel_mno_afk
divyanshu has quit [Quit: Computer has gone to sleep.]
<ggole>
OCaml doesn't seem to do much DCE.
claudiuc_ has quit [Remote host closed the connection]
divyanshu has joined #ocaml
ygrek has quit [Ping timeout: 252 seconds]
<companion_cube>
DCE?
<ggole>
Dead code elimination
<companion_cube>
ah
<companion_cube>
well that's more a problem of optimizing small sequences of assembly instructions
<ggole>
There's various strange things happening at the instruction level, too... allocation will subtract the gc pointer, and then adjust it again immediately with a leal 4(%eax), %eax
manizzle has joined #ocaml
<ggole>
Which is odd twice: first, why adjust at all instead of just producing the right value? And then, why lea instead of the (smaller) addition?
<companion_cube>
might be the same issue?
<ggole>
Actually nope, same size. Ignore the second thing.
<ggole>
Oh well, probably doesn't make much difference except to my OCD
nikki93 has quit [Remote host closed the connection]
Thooms has joined #ocaml
avsm has quit [Quit: Leaving.]
<elfring>
I try to pass two arguments from my small derived class for a parameterized class . Unfortunately, I do not know so far which adjustment I should perform because of the following error message.
<elfring>
# class mapping =
<elfring>
object inherit [int, int] c
<elfring>
...
<elfring>
x#display;;
<elfring>
Error: This class expression is not a class structure; it has type ?compare:('a -> 'a -> int) -> (int * int) list -> [int, int] c
<mrvn>
elfring: you need to pass values, not types
<mrvn>
object inherit c cmp []
<mrvn>
object inherit c ~compare:cmp [] or so
<elfring>
I guess that a type expression is treated a bit different for a class expression, isn't it?
<mrvn>
elfring: yes. In the class expression the inherit instantiates the super class.
<elfring>
The super class that might become one of my favourites here needs to parameters.
<mrvn>
your superclass is actualy a factory
<mrvn>
What is e^(i pi) - 1?
<mrvn>
ups
testcocoon has quit [Quit: Coyote finally caught me]
<elfring>
I wouldn't interpret the class "Omap.c" as a "factory" so far. I would categorise it as a template class.
<mrvn>
elfring: it is a factory. It takes 2 arguments and returns a class object.
<mrvn>
fun cmp list -> object
testcocoon has joined #ocaml
jwatzman|work has quit [Quit: jwatzman|work]
claudiuc has joined #ocaml
zpe has joined #ocaml
<elfring>
I guess that I am more interested in the specification for a class type. I want to get the arguments right for the class "Omap.c".
<elfring>
I try to derive from the class "Omap.c" so that I can safely call the method "iter" in my customised method "display".
<mrvn>
but to define the derived type you need a class type to inherit.
<elfring>
Is the class type just "c" in my example? Should correponding template class parameters be passed between square brackets after the key work "inherit"?
<pippijn>
elfring: all of these are patch review systems
<pippijn>
rietveld is extremely ugly and has no syntax highlighting
<pippijn>
review board is cute (vmware guys made it) but is also a patch review system
<pippijn>
differential is also cute, same problem
<pippijn>
gerrit, not as cute, same problem
<pippijn>
all of these solve a certain problem, more or less well, but not my problem
<whitequark>
phabricator?
<nicoo>
pippijn: Why do you find gerrit uncute ?
<pippijn>
nicoo: just visually
<elfring>
pippijn: In which "code" are you especially interested in for review?
<ggole>
Hmm... say you want to match Foo (Bar, x, y) | Foo (x, Bar, y) | Foo (x, y, Bar). Then a few lines later you want to match Foo (Baz, x, y) | Foo (x, Baz, y) | Foo (x, y, Baz).
<pippijn>
from a functional point of view, it's nice
<nicoo>
pippijn: Also, IIRC Phabricator can do code review, but I never used it
<pippijn>
nicoo: oh
<pippijn>
elfring: the current state of the code
<pippijn>
not one specific patch
<whitequark>
phabricator is a bit weird
<nicoo>
Also, adrien might say unnice things about it
<ggole>
It would be pleasant to be able to abstract over the similarity and write FooArg(Bar, x, y) and FooArg(Baz, x, y) in place of the explict patterns.
<nicoo>
pippijn: Yes, Gerrit's UI isn't very nice, but it got better
* nicoo
mostly uses the CLI anyways
<ggole>
(I have significantly larger and more duplicative patterns than that.)
<pippijn>
ggole: yes
avsm has joined #ocaml
<pippijn>
ggole: I understand, and I have had this problem
<nicoo>
ggole: You want let-patterns ?
<elfring>
pippijn: Do you mean with "code" anything different from text source files?
<ggole>
The problem mostly arises because I'm matching on commutative operations
<pippijn>
elfring: no, exactly that
<pippijn>
elfring: but not just diffs
<ggole>
And you get to write the same thing for each way around
<pippijn>
elfring: e.g. on github, you review patches
<ggole>
Then you get to do it again for each operation :/
<pippijn>
I want to do full audits
<ggole>
And it's an awful lot of the same crud repeated.
<pippijn>
look at the code line by line and comment on questionable ones
<nicoo>
pippijn: Mmmh, it seems that phabricator uses Differential, so no code review there
<pippijn>
nicoo: yes, I thought so
<ggole>
nicoo: I guess that scoping them makes sense
<pippijn>
from what I saw on their website
<nicoo>
pippijn: A colleague uses trac to code-review his student's submissions though
<pippijn>
ggole: yes, commutative operations :\
<pippijn>
ggole: depending on the situation, I either really just write them all out, or I do a normalisation (sort) before the match
<pippijn>
nicoo: hmm trac
Thooms` has joined #ocaml
nikki93 has joined #ocaml
<ggole>
Yeah, I've considered a canonicalising pass. It would be a bit annoying to have to do it though.
<nicoo>
pippijn: Yes, trac :(
<pippijn>
ggole: it's also slower
<pippijn>
because you create new objects just for matching
<elfring>
pippijn: Have you got any requirements that would fit better to the area "software audit review"?
<ggole>
nicoo: yep, that seems like what I want
<nicoo>
Ok :)
<ggole>
...hmm, that seems to go significantly further, too
<pippijn>
elfring: is there a "software audit review" platform out there?
<mrvn>
elfring: You'r problem isn't the template class parameter. It's that you aren't instantiating the class.
<mrvn>
elfring: And that's the third time I told you
<pippijn>
mrvn: what are you talking about?
<companion_cube>
ggole: there is thing named "mocca" I think, that allows to declare algebraic properties on types
<companion_cube>
like commutativity or associativity
<companion_cube>
(I think it's a preprocessor)
chris2 has quit [Ping timeout: 240 seconds]
<mrvn>
ggole: at least you can do: | Foo (Bar, x, y) | Foo (x, Bar, y) | Foo (x, y, Bar) -> (* code once *)
<nicoo>
companion_cube: It does indeed ring a Bell
<mrvn>
pippijn: scroll up
Anarchos has joined #ocaml
<ggole>
mrvn: yeah, not having or patterns would suck pretty hard
<mrvn>
ggole: It's too bad they break down with GADTs a bit
<companion_cube>
GADTs should remain a special weapon
<mrvn>
let foo : type a . a box -> a = function Int x -> | Float x -> x doesn't work
<pippijn>
ah
<companion_cube>
it's normal
<companion_cube>
existential variables would have to be shared among the right part of ->
<mrvn>
companion_cube: just internally duplicate the code
<companion_cube>
sure
<pippijn>
mrvn: but then what is the type of x?
<mrvn>
or extend the type checker to check it for each instance
<ggole>
pippijn: a
<mrvn>
pippijn: int for Int x and float for Float x
<pippijn>
ggole: hmm
_andre has quit [Quit: leaving]
<pippijn>
yes
<mrvn>
pippijn: type of x is a
<ggole>
I can see why it wasn't done that way
<ggole>
But it seems to make sense
<companion_cube>
that would make terrible error messages ^^
<mrvn>
I think the problem is that for the type checker the type of x in Int x is int and Float x is float. Only from the outside it is a
chris2 has joined #ocaml
malo has joined #ocaml
<elfring>
mrvn: class mapping = object inherit c end;;
<elfring>
Error: The class constructor c expects 2 type argument(s), but is here applied to 0 type argument(s)
<mrvn>
elfring: yes. Now you have neither the type arguments nor the arguments
<mrvn>
elfring: you need to ADD the arguments to c, not remove the type arguments
ocp has quit [Quit: Leaving.]
<elfring>
mrvn: At which position should the desired type arguments be specified in the inheritance specification?
ggole has quit []
<mrvn>
elfring: exactly where you had them
dant3 has quit [Remote host closed the connection]
<mrvn>
elfring: inherit [int, int] c ~compare:cmp []
<mrvn>
doesn't GDB have stubs so that every user space process shows up as one thread?
<mrvn>
ups, ewin
<elfring>
mrvn: Should the specification of a comparison function be optional for my example?
<mrvn>
elfring: you need an instance of the right type
<mrvn>
elfring: you could add a cmp parameter to your derived class and just pass it on
mort___ has joined #ocaml
zpe has quit [Remote host closed the connection]
zpe has joined #ocaml
<elfring>
mrvn: I would find it nice if the parameter "cmp" is not needed in my example.
<mrvn>
then don't derive from a class that has one
<elfring>
mrvn: Should it be optionl here? class ['a,'b] c ?compare:(cmp=Pervasives.compare) l = object ...
<mrvn>
yes.
<mrvn>
l isn't though
zpe has quit [Ping timeout: 240 seconds]
<elfring>
Is the error message eventually wrong for my little object creation?
<mrvn>
no
avsm has quit [Quit: Leaving.]
<elfring>
mrvn: Now I notice that the following approach works as expected.
<elfring>
class mapping = object inherit [int, int] c ~compare:Pervasives.compare [] as super end;;
<mrvn>
should work without the compare too sine that is optional
<mrvn>
but the [] is required
eni has joined #ocaml
gustav__ has joined #ocaml
<elfring>
The next variant works also: class mapping = object inherit [int, int] c [] end;;
maattdd has quit [Ping timeout: 268 seconds]
mort___ has left #ocaml []
SrPx_ has joined #ocaml
<elfring>
mrvn: Now it seems that I had got difficutlies to distinguish parameters before and after a "class-path" within an inheritance specification.
Kakadu has quit [Quit: Konversation terminated!]
Thooms` has quit [Quit: WeeChat 0.3.8]
avsm has joined #ocaml
<mk270>
i have used oasis to build a packed module, but i can still access the submodules from code in other directories - is there an example of how to do this right?
shinnya has joined #ocaml
shinnya has quit [Ping timeout: 240 seconds]
<elfring>
mrvn: Thanks for your patience and support.
esden has quit [Ping timeout: 245 seconds]
<SrPx_>
Honest question, why do you guys think ocaml is more popular than Haskell?
<companion_cube>
do we?
esden has joined #ocaml
wolfnn has joined #ocaml
Hannibal_Smith has quit [Quit: Sto andando via]
<mk270>
SrPx_: programming languages are subject to massive network externalities and path dependence, so popularity and unpopularity can arise fairly arbitrarily
<SrPx_>
makes sense
<ousado>
who said ocaml is more popular?
zpe has joined #ocaml
<mk270>
ousado: i certainly didn't :)
zarul has joined #ocaml
zarul has quit [Changing host]
zarul has joined #ocaml
eni has quit [Remote host closed the connection]
esden has quit [Ping timeout: 264 seconds]
<ousado>
SrPx_: did anyone here say that?
knz_ has joined #ocaml
<SrPx_>
No, I made a terribly mistaken, F# is the one functional language that is more popular than Haskell and I was wondering why
<companion_cube>
maybe it's more popular for some applications, like proof assistants? :D
<SrPx_>
mistake*
<SrPx_>
companion_cube: proof assistants in ocaml!?
<companion_cube>
F#'s popularity comes from .NET
<companion_cube>
SrPx_: do you know about coq?
<SrPx_>
companion_cube: yes, why?
<companion_cube>
it's written in OCaml
<SrPx_>
Oh very cool (:
knz has quit [Read error: Connection reset by peer]
<SrPx_>
But there's agda and idris, those are written in haskell ... I think
Enjolras_ has joined #ocaml
esden has joined #ocaml
zpe has quit [Ping timeout: 252 seconds]
Enjolras has quit [Quit: Reconnecting]
patronus_ has quit [Read error: Connection reset by peer]
Enjolras_ is now known as Enjolras
<companion_cube>
yes, indeed
<companion_cube>
still, ML is very popular for this kind of things (considering HOL and isabelle in addition to coq, all three quite popular)
<companion_cube>
it's also hard to assess how popular haskell is for "real" applications
<pippijn>
and also other types of language tools
<pippijn>
coccinelle
<pippijn>
cil
<companion_cube>
why3
<whitequark>
companion_cube: facebook reportedly has large deployed haskell codebase
<pippijn>
felix
<companion_cube>
whitequark: facebook uses many languages ^^
<ousado>
haxe
<pippijn>
whitequark: I heard facebook uses ocaml to do static analysis on php
<companion_cube>
indeed
<jwatzman|work>
pippijn: yep, i work for FB, i am writing ocaml right now :)
<companion_cube>
its new "hack" language uses ocaml
<pippijn>
ousado: you can use sparse to check generated code
<pippijn>
it's quite complete
nikki93 has quit [Remote host closed the connection]
lostcuaz has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
<ousado>
what is it written in?
<pippijn>
C
<pippijn>
it's a library
<ousado>
yep, found it
<pippijn>
one thing I didn't like about my parser is the AST
<pippijn>
I do things differently, nowadays
<ousado>
what don't you like about it?
<ousado>
(I'm just looking at it)
<jwatzman|work>
ousado: we are doing way too much crazy systems stuff to deal with reasoning about laziness or having to encapsulate everything in purely functional style
<pippijn>
I don't like the use of polymorphic variants for "extra information attached to nodes"
<pippijn>
I don't like that every node has its "extra information" inside the node
<jwatzman|work>
ousado: pure FP is good in a lot of cases in our opinion, but occasionally you just want mutable state :)
<pippijn>
I don't like the fact that type information is a wrapper node around a node of the same type as the node itself
<ousado>
jwatzman|work: given your "JIT" requirement I totally understand the decision, I was just curious because of O'Sullivan
<ousado>
pippijn: I see, so you'd use another AST now?
<pippijn>
yes
<pippijn>
very similar to this
<jwatzman|work>
ousado: a lot of the external press got it wrong; he's been our manager and has given some useful input, but Julien Verlaguet has really been the brains behind the type system
<pippijn>
in fact, the same as this
<pippijn>
but with records around each node containing the extra info
<jwatzman|work>
ousado: I don't want to downplay the kickass work O'Sullivan has done, it just hasn't been a lot of *engineering* work :)
dant3 has joined #ocaml
<ousado>
jwatzman|work: yes, the wired article got a lot of things wrong
<kmicinski>
What's the typical diagnosis if I install a package with opam, and then properly switch and eval my config setup, but then ocamldep can't find a package
aurynj has quit [Ping timeout: 246 seconds]
ousado has joined #ocaml
<kmicinski>
Ah, I see the problem, ocamlbuild is using a non OPAM ocaml