malc has quit [Read error: 110 (Connection timed out)]
skylan has quit [Connection reset by peer]
skylan has joined #ocaml
TrOn has joined #ocaml
mrvn_ has quit [Read error: 104 (Connection reset by peer)]
mrvn has joined #ocaml
lament has joined #ocaml
skylan has quit [Read error: 104 (Connection reset by peer)]
palomer has joined #ocaml
skylan has joined #ocaml
palomer has quit [Remote closed the connection]
Kinners has left #ocaml []
foxen5 has quit [Read error: 104 (Connection reset by peer)]
<pattern_>
is there a command that i can use to look up an ocaml keyword or module function in the documentation?
skylan has quit [Read error: 104 (Connection reset by peer)]
skylan has joined #ocaml
<mrvn>
The list of modules, values and keywords
<mrvn>
Part V - Apendix
<pattern_>
yeah, i know the manual exists :P
<pattern_>
but i was hoping there was something like "perldoc" for ocaml, where you can type "ocamldoc let" and be given a bit of reference documentation on it
<pattern_>
of course i can write something that searches through the html manual index, and jump to that
<pattern_>
btw, how did your program do in the pfc, mrvn?
<mrvn>
pattern_: no results yet but its buggy
<mrvn>
It gets the score for the board wrong slightly, which is pretty fatal.
<pattern_>
do they allow you to send in bugfixes?
<mrvn>
That would defy having a deadline.
<pattern_>
yeah, but it's for fun :)
<mrvn>
Its not like a +/- swap or something. A bit more fundamental.
<pattern_>
too bad
<mrvn>
According to my own test I'm not even last even with the bug
<pattern_>
well, you can still fix it, and then try it against the other entries on your own, right?
<mrvn>
And its not like the others don't have bugs too :)
<mrvn>
pattern_: I'm doing that.
<pattern_>
cool
<pattern_>
i'm rooting for you!
<mrvn>
I'm gonna send in a enhanced version just for fun too. non competing.
<pattern_>
great
<mrvn>
The problem is that my entry is a lot faster than most others. I can play much bigger boards against myself in a reasonable time. But against the other entries that means letting it run a day, which sucks for testing and tweaking.
<mrvn>
Still having problems with the first move though, timewise. A 1000x1000 filed takes about 36 seconds to initialise the board and just play the first move it finds. :(
<pattern_>
that's a big board, though
<mrvn>
The contest said that board would be 1000x1000 max. :)
<mrvn>
A million possible moves.
<pattern_>
does the first move even matter that much?
<mrvn>
Unless there are a lot of initialy blcoked fields.
<mrvn>
Only if its the wrong one :)
<pattern_>
if your program is that much faster than the others then it could just make a random move as its first move, and then think on the opponent's time
<mrvn>
That what it does.
<pattern_>
or set a time limit for the first move, and have it make the best move it's thought of in that time limit
<mrvn>
Just scanning in the board and initialising the data structures takes 36 seconds.
<pattern_>
why is that?
<pattern_>
and is that slower than the other programs?
<mrvn>
The game seperates into subgames that are connected.
palomer has joined #ocaml
<mrvn>
I read in the board and do a flood-fill on the first empty field I find.
<mrvn>
Until the filling is done there no checking for timeouts and a empty 1000x1000 field takes taht long to flood-fill.
<pattern_>
what's a flood-fill?
<mrvn>
Imagine the board in 3D. + is a raised wall and - empty space. The first - if find I fill up with paint and watch where it flows. I flood the board.
<mrvn>
Figuratly speaking.
<pattern_>
why do that?
<mrvn>
To find the connected area.
<pattern_>
but don't the - tell you where that is?
<mrvn>
There can be many regions.
<mrvn>
+++
<mrvn>
+-+-+
<mrvn>
+++++
<mrvn>
+-+-+
<mrvn>
+++++
<mrvn>
Like those 4 regions.
<pattern_>
right
<pattern_>
so a flood fill just checks to see if those areas are connected
<mrvn>
Actually the regions above are realy realy good.
<pattern_>
it doesn't really "fill" anything, but sees if - are ajacent
<mrvn>
The first thing I do is to find regions of size 1 and all other empty spaces.
<mrvn>
pattern_: Yes. the filling comes from computer graphics. You draw figue on the screen and then flood-fill it from a point on the inside of the figure.
<pattern_>
yes, that's what i first thought of when you said "flood-fill"
<mrvn>
In the old days you could watch the algorithm actually fill up the screen.
<pattern_>
but it's not like you were modifying the -'s, but just seeing their connections, which makes sense
<pattern_>
yep, i was there in the old days :)
<mrvn>
pattern_: Actually I am. I'm coloring them to belong to a certain subgame.
<pattern_>
i see
<mrvn>
So when the oponent makes a move I look up the color of the field and know what subgames was played.
<pattern_>
cool
<pattern_>
so, instead of reading the whole board, you could just make a move in the first subgame you find
<pattern_>
and then continue filling in the board while your opponent thinks
<mrvn>
I could make the flood-fill check for timeouts and split it up over the first several moves. But I think its unlikely someone realy wants to play a 1000x1000 empty board.
<pattern_>
some guy made up a chess-like game with many possible moves to make it hard for computers to brute-force their way through
<pattern_>
you get $10k if you beat the best human player... and that is good for 20years
<mrvn>
neve heard of it
<pattern_>
and you get $1k if you beat the best computer opponent in december of this year
lament has quit ["Did you know that God's name is ERIS, and that He is a girl?"]
<pattern_>
yeah, i'd never heard of it until recently either... i don't think most anyone has heard of it, because it's new... which gives an advantage to someone who wants to write a program to play it
<pattern_>
and the humans have a disadvantage, because there isn't a huge population of great arimaa players, because the game is so new and not popular at all
<pattern_>
in fact, i bet the human opponent that your computer will be playing against will be the creator of the game :)
<pattern_>
"In Arimaa a player has about 2,000 to 3,000 moves in the first turn depending on the way they chose to setup the pieces. During the mid-game the number of possible moves can range from about 5,000 to 40,000. If we assume an average of 20,000 possible moves at each turn, looking forward just 2 moves (each player taking 2 turns) means exploring about 160 million billion positions."
<pattern_>
and "There are more than 64 million different ways in which each player can setup their pieces at the start of the game"
<mrvn>
That game does seem complex
<pattern_>
if you go through the java tutorial, it's actually not hard to learn
<pattern_>
but it's definately more complex than tic-tac-toe, or othello or connect-four
<pattern_>
and more complex than chess, as far as diversity of moves go
<pattern_>
it's supposed to be more of a positional game than chess, though... kind of like go
<pattern_>
it's more challenging for a human to learn to play chess well, though, because there is a huge body of knowledge on how to play well
<pattern_>
there isn't anything like that in arimaa... so you're likely to do just about as well as any other arimaa player in the world, with a bit of practice
<pattern_>
^--- with vim, after dropping in this plugin :P
<pattern_>
well, i actually also had to tell it what ocaml comments looked like
<pattern_>
but that took 5 seconds, and i'm sending the author a patch so he can include it in his script
<mrvn>
whats a^b in ocaml?
<mrvn>
for ints
mattam has joined #ocaml
lament has joined #ocaml
mattam has quit [calvino.freenode.net irc.freenode.net]
mrvn has quit [calvino.freenode.net irc.freenode.net]
mattam has joined #ocaml
mrvn has joined #ocaml
TrOn has quit [Remote closed the connection]
TrOn has joined #ocaml
foxen5 has joined #ocaml
pattern_ has quit ["..."]
pattern_ has joined #ocaml
pattern_ has left #ocaml []
pattern_ has joined #ocaml
pattern_ has quit [Client Quit]
pattern_ has joined #ocaml
lament has quit ["Did you know that God's name is ERIS, and that He is a girl?"]
det has joined #ocaml
docelic|sleepo is now known as docelic
docelic is now known as docelic|away
mellum has quit [Read error: 110 (Connection timed out)]
mellum has joined #ocaml
<det>
How can I write a type for a class that takes argument ?
<det>
like:
<det>
class ['a] Cons head tail =
<det>
object
<det>
val head = head
<det>
val tail = tail
<det>
end
<det>
;;
<det>
class type ['a] Cons : 'a -> 'a Cons ->
<det>
object
<det>
val head : 'a
<det>
val tail : 'a Cons
<det>
end
<det>
;;
<det>
something like that ?
<mrvn>
let make_cons = function head tail -> new Cons head tail;;
<mrvn>
class ['a] cons head tail = object val head = head val tail = tail end;;
<det>
no, I want to know how I could make a type that is the same type as the the "class ['a] cons"
<mrvn>
that?
<det>
I don't know where to stick the information for the arguments to the class
<mrvn>
what do you mean?
<det>
mrvn, that is what I want, however I need to make a "class type" for the class you just pasted
<mrvn>
type 'a cons_type = 'a cons;;
<det>
hrmm
<det>
how could I define that without first defining 'a cons :)
<mrvn>
can you?
<det>
I would imagine so
<mrvn>
class type ['a] cons = object val head : 'b val tail : 'c end;;
<det>
ohh
<det>
the arguments the class takes are irrelevant ?
<mrvn>
The class takes no arguments.
<det>
then what are head and tail in: class ['a] cons head tail =
<mrvn>
parameter for the Constructor creating a class.
<det>
2~vvclass ['a] cons head tail =Or for creating a class are irrelevant to the type of the object I guess
<det>
s/2~vv//g
<det>
ack
<det>
keyboard went crazy
<det>
ignore that whole statement
<mrvn>
det: If they were you would get a ['a*'b*'c] Cons
<mrvn>
det: You probably want the following anyway:
<det>
what I mean to say is the arguments to the constructor have nothing to do with the object I am beginning to realize
<mrvn>
class ['a] cons (head:'a) (tail:'a cons) = object val head = head val tail = tail end;;
<det>
mrvn, yeah, I have that exact class in my other window :p
<mrvn>
Or maybe:
<mrvn>
# module type cons = sig class ['a] cons : 'a -> 'a cons -> object val head : 'a val tail : 'a cons end end;;
<mrvn>
module type cons =
<mrvn>
sig
<mrvn>
class ['a] cons :
<mrvn>
'a -> 'a cons -> object val head : 'a val tail : 'a cons end
<mrvn>
end
<det>
s~cvl\s~cvnl\s~cvlv\s~cvl\sI am trying to mmake a more generic sequence, that supports this (car) and next (cdr) operations so that a function can accept any sequence type
<det>
keyboard :/
<det>
I don't think you can accomplish that with modules
<mrvn>
Module List has it
<mrvn>
You only need classes if you want to use virtual method instead of higher level functions
<det>
class type ['a] cons :\
<det>
'a -> 'a cons -> object val head : 'a val tail : 'a cons end
<det>
IGNORE
<det>
soething is really essed up with y keyboard
<det>
rebooting
<det>
brb
det has quit ["ircII EPIC4-1.1.2 -- Are we there yet?"]
det has joined #ocaml
<det>
sorry
<det>
back
<det>
mrvn, still around ?
<mrvn>
yes
<det>
yes, what I want is virtual functions
<mrvn>
for what?
<det>
I want a function to take any type that supports the this (lisp's car) and next (cdr) methods
<mrvn>
that not a virtual function
<det>
car and cdr wouldnt be if I dont know the exact type ?
<mrvn>
car: 'a cons -> 'a
<mrvn>
what else do you need to know?
<det>
I would make a class type called sequence
<mrvn>
than inherit cons
<mrvn>
then even
<det>
and then do something like (new cons 1 old_cons :> sequence)
<det>
to pass to the function
<det>
well, the implementation might be different than cons
<det>
maybe an array or btree or something
<det>
I think I understand what to do now
<mrvn>
define a common interface and inherit that in both clases.
<mrvn>
or use modules
<det>
yeah, that is what the "class type sequence" will be :)
<det>
mrvn, I dont think it is possible with modules
<mrvn>
with signatures it should be no problem
<mrvn>
just like the comparable signature
<det>
I would do something like Sequence.next ?
<mrvn>
module type sequence = sig type 'a cons
<mrvn>
val car : 'a cons -> a
<mrvn>
val cdr : 'a cons -> 'a cons
<mrvn>
end;;
<mrvn>
And then you implement that signature whatever way you like.
<mrvn>
Look at signature and functors in the docs.
<det>
how could I implement that signature ?
<mrvn>
never done it, rtfm
<det>
well, it would be very cool if I could do this without classes
<det>
thanks
Kinners has joined #ocaml
foxen5 has quit [Read error: 104 (Connection reset by peer)]
Kinners has quit [calvino.freenode.net irc.freenode.net]
det has quit [calvino.freenode.net irc.freenode.net]
mrvn has quit [calvino.freenode.net irc.freenode.net]
mattam has quit [calvino.freenode.net irc.freenode.net]
Kinners has joined #ocaml
det has joined #ocaml
mrvn has joined #ocaml
mattam has joined #ocaml
mrvn has quit [calvino.freenode.net irc.freenode.net]
mattam has quit [calvino.freenode.net irc.freenode.net]
Kinners has quit [calvino.freenode.net irc.freenode.net]
det has quit [calvino.freenode.net irc.freenode.net]
Kinners has joined #ocaml
det has joined #ocaml
mattam has joined #ocaml
mrvn has joined #ocaml
asqui has quit [Excess Flood]
asqui has joined #ocaml
<mrvn>
fd0 ist 9"
<mrvn>
ups
<musasabi>
is it possible to have a reference type whose equivalence comparison (=) is based on identity?
det has quit ["ircII EPIC4-1.1.2 -- Are we there yet?"]
<mrvn>
physical identify or structural?
<musasabi>
physical
<mrvn>
= is structural and == is physical
<musasabi>
I am trying to implement a symbol module for use in a compiler, and would like to avoid needless string comparisons.
<mrvn>
let a = ref 1;
<mrvn>
# let a = ref 1;;
<mrvn>
val a : int ref = {contents = 1}
<mrvn>
# let b = a;;
<mrvn>
val b : int ref = {contents = 1}
<mrvn>
# a=b;;
<mrvn>
- : bool = true
<mrvn>
# a==b;;
<mrvn>
- : bool = true
<mrvn>
# let c = ref 1;;
<mrvn>
val c : int ref = {contents = 1}
<mrvn>
# a=c;;
<mrvn>
- : bool = true
<mrvn>
# a==c;;
<mrvn>
- : bool = false
<mrvn>
Thats what you want?
<musasabi>
i'll explain with a little more detail.
<musasabi>
I implement symbols in a module with a hashtable. Identifiers are inserted into the table and somekind of symbol is obtained. Now these symbols can be compared without the cost of string comparisons. Using the address of the string in the hashtable as the symbol instead of some random integer would give reverse mapping for free.
<musasabi>
i.e. I want (=) return true if both references point to the physically same object.
<mrvn>
thast ==
<musasabi>
no, == is different
<musasabi>
let c = "foo";; ref c == ref c;; => false
<mrvn>
let str = "Hallo";;
<mrvn>
let s1 = ref str;;
<mrvn>
let s2 = ref str;;
<mrvn>
# s1=s2;;
<mrvn>
- : bool = true
<mrvn>
# s1==s2;;
<mrvn>
- : bool = false
<mrvn>
# !s1 == !s2;;
<mrvn>
- : bool = true
<mrvn>
You have to deref the references and then ==
det has joined #ocaml
<musasabi>
that degenerates into string comparison then.
<musasabi>
I want:
<mrvn>
no, == checks the address
<mrvn>
# let s3 = ref "Hallo";;
<mrvn>
val s3 : string ref = {contents = "Hallo"}
<mrvn>
# !s1 == !s3;;
<mrvn>
- : bool = false
<mrvn>
Same sting, different address
<Kinners>
anyone know how to use ocpp?
<musasabi>
!s1 == !s3 seems to be what I am looking for.
<det>
mrvn, well I made a Sequence module type and a List module type the supports the Sequence Type (http://www.twistedmatrix.com/users/chris/mod.ml) but I don't see how I can have a function accept any type with the Sequence sig (you can't Sequence.car because it is only a type)
<det>
mrvn, I think you can only do that sort of thing with classes still
<mrvn>
det: that would make signatures useless and they aren't.
<musasabi>
is there any way to define a type to use such operation instead of the standard '=' behaviour? Some other code uses = for comparisons and I'd have to functorize it all.
<mrvn>
How would Module List work otherwise?
<det>
mrvn, what would make them useless ?
<mrvn>
det: i signatures wouldn#t work.
<mrvn>
musasabi: no. normaly such functions take a "cmp" function
<mrvn>
like List.sort
<det>
mrvn, I mean what is "that" in "that would make signatures useless"
<mrvn>
det: that you can only do that with classe. Your problem is exactly what signatures are for.
<mellum>
musasabi: you can define your own = for abstract data types in C... don't know whether it's possible from within Ocaml, though
<det>
mellum, you can ? ( you mean == ) ?
<det>
mellum, maybe you mean c++ ?
<det>
mrvn, according to the tutorial, signatures are for only showing parts of a module that you want
<mrvn>
det: read the next chapter about functors.
<mrvn>
They define a ORDERED_TYPE and use that in a Set module.
<det>
so I can only do what I want in a functor
<det>
for example
<det>
you couldnt have a function that could take any ORDERED_TYPE
<det>
?
<mrvn>
det: you would, though the functor.
<mellum>
det: I mean C used to extend Ocaml
<mellum>
det: of course that won't change the C '='
<mrvn>
s/though/through/
<mellum>
or ==
<det>
mrvn, all you can do with functors is create new modules
<mrvn>
det: It has to store the function pointer for car and cdr somewhere. Same for functors and classes.
<det>
mrvn, it could just pass them :)
<mrvn>
manually? both o them? All the time?
<det>
yeah
<det>
but
<mrvn>
What if it where 100 functions? Do you allways want to pass them?
<det>
well
<det>
it could keep them in one structure
<det>
and pass that
<mrvn>
then you would manually implement functors.
<det>
well
<det>
imagine this case where I dont think functors could work
<det>
I have a a scene graph of objects, and each object I put in the scene graph knows how to draw itself, I would like to be able to add teh the SG any type that supports a certain interface (knows how to draw itself)
<det>
I could do that with classes
<det>
I dont see how with modules and functors
<det>
it could be possible
<mrvn>
draw would be a virtual function
<det>
yes, but it's not possible without classes, right ?
<mrvn>
possibly.
<det>
well, with the sequence example, car and cdr would also be virtual functions
<mrvn>
You can easily do it with closures
<mrvn>
and records
<det>
you mean by passing a record around with all the neccesary fucntions (draw) ?
<mrvn>
det: No, a closure darw:unit->unit
<det>
ohh
<mrvn>
and a record if you need more than just draw
<det>
good point
<det>
hrmm
<det>
that would probally be slower than classes :)
<det>
with all the closure overhead
<mrvn>
The problem with your graph is that it needs to store the different objects somehow. You can't just make a list of them.
<det>
right
<mrvn>
But the closure has the same type (draw:unit->unit) for all objects so you can easily store them.
<mrvn>
The virtual table of a class is nothing but a record of closures.
<det>
oh yeah, you only need to do it once
<det>
forgot
<mrvn>
But if you have a set of different objects with lots of subsets. Modeling that with classes and inheriance is probably easiers.
<det>
easier than what ?
<det>
I see no alternative
<mrvn>
than functors or closures
<det>
I dont see it being possible with functors at all
Kinners has left #ocaml []
<mrvn>
functors work if you want to make a module that works with some impelemntation of an interface but not with different implementations at the same time.
<det>
right, and I need to work with different implementations at the same time
<det>
put very well
<det>
thanks :)
<det>
so classes it is
<det>
thanks very much for your help
<det>
I am starting to grasp ocaml now :)
<det>
sleep now
<det>
night
<mrvn>
with classes you need to cast them quite often to get the type system to grasp what you mean.
<det>
you mean like (new Cube 10 :> SceneNode) ?
<mrvn>
yep
<det>
yeah, I wish that if I passed a Cube object to a function expecting a SceneNode it would pass it as a SceneNode :/
<det>
like c++ does
<mrvn>
det: somehow you can do that I think.
<det>
how active is the ocaml mailing list ?
<mrvn>
check the examples for classes. There are different ways of inheriting I think.
<det>
ohh
<det>
ok
<det>
I will do that in the morning
<det>
thanks again
det has quit ["sleep now"]
taw has joined #ocaml
<taw>
mmm
<taw>
i want 3d vectors
<taw>
is some representation of them more efficient than other ?
<mrvn>
type vec = float * float * float;;
<mrvn>
What else can you do?
<taw>
like (float*float*float) or {x:float, y:float, z:float}
<taw>
well, i can do record
<taw>
i wonder if the difference will be big
<mrvn>
Array.make 3 0.
<taw>
or i can use curried functions
<taw>
lot of ways
<taw>
is there maybe some document which describes efficiency of them ?
<mrvn>
Do you want them functional or imperative?
<taw>
what can be imperative in math ?
<taw>
oh
<taw>
i think i'll need functional only
<mrvn>
an Array would be imperative, a tuple functional.
<mrvn>
If you have functional you have to copy the vector upon each operation. Even if only x changes or something.
<mrvn>
But that shouldn't make a difference
<taw>
usually all 3 would change
<taw>
but it would be nice if it was able to optimize vectoradd (x,y,z) (w,0,0) to (x+w,y,z)
<taw>
etc
<mrvn>
You can define them and define accersor functions and never use the representation directly.
<mrvn>
That way you can change it with a few lines.
<mrvn>
taw: the test for 0 takes longer than just adding them.
<taw>
but in case 0 is static
<taw>
known at copilation
<mrvn>
but you need to jump to the right case, which takes ages.
<taw>
so that i won't need special vector_add_only_x
<taw>
etc.
<taw>
jump how ?
<mrvn>
The chance of a vector to actually be 0 in one component should be very slim.
<taw>
compiler will just insert the right case
<taw>
i don't mean to find out zeros during runtime
<taw>
but if in some place we explicitely add 0
<taw>
to eliminate that
<mrvn>
how should vector_add a b know that a has zeros or not during compiletime?
<taw>
it's not vector_add a b
<taw>
but
<taw>
let vector_some_weird_operation x y = vector_add (vector_inverse x) (2.0,y,0.0)
<taw>
something like that
<taw>
is ocaml compiler smart enough ?
<mrvn>
but the vector_add function would have the pattern matching even for vector_add a b
<mrvn>
The case abov would probably inline and optimize.
<taw>
you seem to think c ;)
<taw>
of course ocamls inlines everything
<mrvn>
not verything and not accross modules
<taw>
but it inlines enough
<mrvn>
still wouldn't remove the test for 0.0 in the general function
<taw>
generally ocaml should optimize x+contant+contant to x+contant and x+0 to x
<mrvn>
sure, but if you pattern match you have tests for 0.0 in there.
<mrvn>
Just add all 3 componnents and hope that the inlineing will remove the +0.0
<taw>
mmm
<taw>
is it described somewhere?
<taw>
what optimalizations ocaml does ?
<mellum>
Well, I'm pretty sure it does constant folding and strength reduction.
<taw>
with floats too ?
<mrvn>
mellum: why doesn#t zsh use local variables in functions?
<taw>
i know ansi c forbids touching floats
<mrvn>
does it? why?
<mrvn>
Don't tell me 1.0/2.0 doesn't get optimized to 0.5
<taw>
floating point operations aren't associative
<taw>
(x + 1.0 - 1.0) can't become optimized to x
<mrvn>
They are still constant sometimes.
<taw>
it must be (x + 1.0) - 1.0
<taw>
c compilers are allowed to only touch contant-constant operations
<taw>
and must do everything in order given
<taw>
1e-9 + 1.0 = 1.0
<taw>
1e-9 + 1.0 - 1.0 = 1.0 - 1.0 = 0.0 != 1e-9
<taw>
that's the idea
<taw>
they had
mattam_ has joined #ocaml
mrvn has quit [calvino.freenode.net irc.freenode.net]
mattam has quit [calvino.freenode.net irc.freenode.net]
taw has left #ocaml []
mrvn has joined #ocaml
<mrvn>
re
foxen5 has joined #ocaml
docelic|away is now known as docelic
xtrm has quit ["byebyeX"]
xtrm has joined #ocaml
docelic is now known as docelic|away
mattam has joined #ocaml
mattam_ has quit [Read error: 60 (Operation timed out)]
foxen5 has quit [Read error: 104 (Connection reset by peer)]
xxd has quit [Read error: 110 (Connection timed out)]
xxd has joined #ocaml
foxster has joined #ocaml
polin8 has quit ["Lost terminal"]
systems has joined #ocaml
polin8 has joined #ocaml
systems has left #ocaml []
mrvn_ has joined #ocaml
mrvn has quit [Read error: 110 (Connection timed out)]
TachYon has joined #ocaml
TachYon has quit ["Client Exiting"]
chrisb` has joined #ocaml
xxd has quit [Read error: 110 (Connection timed out)]
xxd has joined #ocaml
xxd has quit [Read error: 101 (Network is unreachable)]
xxd has joined #ocaml
xtrm_ has joined #ocaml
xtrm_ has quit [Client Quit]
xxd has quit [Read error: 101 (Network is unreachable)]
xxd has joined #ocaml
foxster has quit [Read error: 104 (Connection reset by peer)]
chrisb` has quit [Read error: 54 (Connection reset by peer)]
chrisb has joined #ocaml
foxster has joined #ocaml
Kinners has joined #ocaml
TachYon has joined #ocaml
beedauchon_ has joined #ocaml
seth has joined #ocaml
<seth>
I'm trying to build OCaml, and getting many errors in the tk directory. Has anyone built it against a recent version of tk?
seth has quit [Remote closed the connection]
seth has joined #ocaml
TachYon has quit [Remote closed the connection]
beedauchon_ has quit [Read error: 60 (Operation timed out)]
<seth>
os ocaml active? I get no response from a request to subscribe to the list, the IRC site listed on the web site doesn't resolve, and the source doesn't compile.
<Riastradh>
It compiles for me.
<seth>
I get tons of errors in the tk directory. What version of tk are you using?
* Riastradh
doesn't compile it with Tk.
<whee>
I compile with tk 8.4, works fine D:
<seth>
doesn't compile with 8.4.1
<Kinners>
there's a slight change needed for 8.4.1 I think
<Riastradh>
8.3 for me, if it's compiling with Tk behind my back.
foxster has quit [Read error: 104 (Connection reset by peer)]
<seth>
whee: no, the fix in the bug report has no effect, although it definitely is the same problem.
<seth>
whee: No, I'm wrong, it does fix the problem in the bug report but then you just get another problem immediately afterwards.
<seth>
whee: I'll try putting the same #define in that file also.
<Kinners>
I added it to the top of cltkImg.c, compiled ok for me
<seth>
Kinners: yes, but then the tkAnim file fails to compile
<seth>
Kinners: But I added the define to that file also and it appears to be building now.
<seth>
Kinners: sorry, tkAnimGIF.c
<seth>
OK, now I'm out of the TK directory so I think I'm OK. Thanks, all.
foxster has joined #ocaml
<seth>
Any recommendations on what doc to start with? I know Haskell, C/C++, Java, Python, and Ruby in great detail and I have had some exposure to ML.
<Riastradh>
The OCaml manual.
<Riastradh>
There's a bit of a tutorial at the beginning of it.
<seth>
Riastradh: OK, I'll start there, thanks.
<Riastradh>
ocaml.org -> Somewhat bottomish corner of the right-hand toolbar is a link to it.