chrisdotcode_ has quit [Read error: No route to host]
eikke has quit [Ping timeout: 258 seconds]
raichoo has quit [Quit: leaving]
osnr has joined #ocaml
osnr has quit [Changing host]
osnr has joined #ocaml
osnr has quit [Quit: Leaving.]
osnr has joined #ocaml
osnr has quit [Changing host]
osnr has joined #ocaml
rgrinberg has quit [Ping timeout: 264 seconds]
Drup has quit [Ping timeout: 260 seconds]
dsheets has quit [Ping timeout: 256 seconds]
malfunct has left #ocaml []
jcao219 has quit [Ping timeout: 256 seconds]
nalaginrut has quit [Ping timeout: 256 seconds]
nalaginrut has joined #ocaml
rgrinberg has joined #ocaml
ttamttam has joined #ocaml
ttamttam has left #ocaml []
awm22 has quit [Quit: Leaving.]
ttamttam has joined #ocaml
nalaginrut has quit [Ping timeout: 258 seconds]
UncleVasya has joined #ocaml
ontologiae has joined #ocaml
ttamttam has left #ocaml []
ggole has joined #ocaml
djcoin has joined #ocaml
pango has quit [Ping timeout: 264 seconds]
pango has joined #ocaml
ulfdoz has joined #ocaml
ontologiae has quit [Quit: leaving]
patronus has quit [Ping timeout: 255 seconds]
jsvgoncalves has quit [Remote host closed the connection]
ontologiae has joined #ocaml
ontologiae has quit [Client Quit]
ontologiae has joined #ocaml
ontologiae has quit [Client Quit]
ontologiae has joined #ocaml
Arsenik has joined #ocaml
jbrown__ has joined #ocaml
osnr has quit [Quit: Leaving.]
cdidd has quit [Read error: Connection reset by peer]
ollehar has joined #ocaml
ontologiae has quit [Read error: No route to host]
ontologiae has joined #ocaml
Kakadu has joined #ocaml
ccasin has quit [Ping timeout: 245 seconds]
q66 has joined #ocaml
barbapapa has joined #ocaml
ontologiae has quit [Ping timeout: 256 seconds]
eikke has joined #ocaml
jon-shape has joined #ocaml
ollehar has quit [Ping timeout: 258 seconds]
eikke has quit [Ping timeout: 248 seconds]
ccasin has joined #ocaml
rwmjones has quit [Ping timeout: 264 seconds]
rwmjones has joined #ocaml
yacks has quit [Quit: Leaving]
ontologiae has joined #ocaml
tobiasBora has joined #ocaml
<tobiasBora>
Hello !
<tobiasBora>
Yesterday, you explain me how to create a function like Printf.print, for exemple doing a debug mode.
<tobiasBora>
This is the good function : let print_d = Printf.ksprintf (fun s -> if !debug_mode then print_endline s else ());;
<tobiasBora>
I tried to modify this function to return a string instead of print the result : let string_d = Printf.ksprintf (fun s -> if !debug_mode then s else "");;
<tobiasBora>
It works when I run it in the toplevel, but when I compile I've this error :
<tobiasBora>
Error: The type of this expression,
<tobiasBora>
('_a, unit, string, string) format4 -> '_a,
<tobiasBora>
contains type variables that cannot be generalized
<asmanur_>
tobiasBora: you need to eta-expand, that is write let string_d x = ... x
<asmanur_>
so that the type of your format gets generalized (otherwise it is not, it is called the value restriction)
<tobiasBora>
asmanur_: Indeed it works... Thanks ! But I don't understand why we need this argument here and not in print_d ?
Neros has joined #ocaml
<tobiasBora>
And can we always use eta-expansion or sometimes we mustn't give any argument ?
<asmanur_>
tobiasBora: you should have the same problem with the print_d variant
<tobiasBora>
asmanur_: no, this function compile without any problem...
<asmanur_>
tobiasBora: well
<asmanur_>
you were probably using print_d
<asmanur_>
so that the '_a is fixed to this type
<asmanur_>
and not the string_d
<asmanur_>
tobiasBora: what happens is that when ocaml sees something like let f = ...
<asmanur_>
if ... is not a function its type does not get generalized
<asmanur_>
(in particular if it is an application)
<asmanur_>
so the type of f may contain type variables not yet known which ocaml denote '_a
<tobiasBora>
Indeed I use only print_d in my code ^^
<tobiasBora>
And when does ocaml accept generalised type ?
<ggole>
Roughly speaking, when the bind expression of a let is a syntactic value
<ggole>
(OCaml actually uses a slightly relaxed version of that rule)
jbrown__ has quit [Ping timeout: 252 seconds]
ollehar has joined #ocaml
Drup has joined #ocaml
ollehar has quit [Ping timeout: 268 seconds]
yacks has joined #ocaml
jbrown__ has joined #ocaml
<tobiasBora>
ggole: what is exactly a syntactic value ?
<ggole>
Things that aren't evaluated more (ugh, pretty lame description)
<ggole>
Examples: 1, [], Foo, (fun x -> x)
Neros has quit [Read error: Connection reset by peer]
samebchase has joined #ocaml
UncleVasya has quit [Ping timeout: 256 seconds]
chris2 has quit [Remote host closed the connection]
awm22 has joined #ocaml
yacks has quit [Read error: Operation timed out]
<tobiasBora>
I see. Thanks !
smerz_ has quit [Ping timeout: 268 seconds]
emmanuelux has joined #ocaml
emmanuelux has quit [Remote host closed the connection]
gildor has joined #ocaml
Neros has joined #ocaml
tobiasBora has quit [Ping timeout: 252 seconds]
eikke has joined #ocaml
eikke has quit [Ping timeout: 256 seconds]
chris2 has joined #ocaml
yacks has joined #ocaml
sgnb` has joined #ocaml
sgnb has quit [Remote host closed the connection]
wmeyer has quit [Ping timeout: 256 seconds]
Armael has joined #ocaml
smerz_ has joined #ocaml
eikke has joined #ocaml
tobiasBora has joined #ocaml
ontologiae has quit [Ping timeout: 256 seconds]
madroach has quit [Quit: leaving]
madroach has joined #ocaml
jsvgoncalves has joined #ocaml
djcoin has quit [Quit: WeeChat 0.3.9.2]
tobiasBora has quit [Read error: Operation timed out]
tobiasBora has joined #ocaml
dsheets has joined #ocaml
Plainview has joined #ocaml
darkf has quit [Quit: Leaving]
Plainview has quit []
rudi has joined #ocaml
rgrinberg has quit [Ping timeout: 256 seconds]
jcao219 has joined #ocaml
jsvgoncalves has quit [Read error: Connection reset by peer]
cdidd has joined #ocaml
cdidd has quit [Ping timeout: 264 seconds]
cdidd has joined #ocaml
fraggle_laptop has joined #ocaml
Anarchos has joined #ocaml
jcao219 has quit [Read error: Connection reset by peer]
jcao219 has joined #ocaml
dsheets has quit [Quit: Leaving]
ontologiae has joined #ocaml
fraggle_laptop has quit [Remote host closed the connection]
Tobu has quit []
smerz_ has quit [Ping timeout: 258 seconds]
iZsh has quit [Quit: Coyote finally caught me]
iZsh has joined #ocaml
yacks has quit [Quit: Leaving]
barbapapa has quit [Remote host closed the connection]
jcao219 has quit [Read error: Connection reset by peer]
jcao219 has joined #ocaml
gnuvince has quit [Ping timeout: 256 seconds]
RagingDave has joined #ocaml
ggole has quit []
Arsenik has quit [Remote host closed the connection]
yacks has joined #ocaml
rudi1 has joined #ocaml
tobiasBora has quit [Ping timeout: 264 seconds]
rudi has quit [Ping timeout: 264 seconds]
yezariaely has quit [Remote host closed the connection]
yezariaely has joined #ocaml
chrisdotcode has joined #ocaml
rudi2 has joined #ocaml
ttamttam has joined #ocaml
rudi1 has quit [Ping timeout: 252 seconds]
chrisdotcode has quit [Quit: No Ping reply in 180 seconds.]
chrisdotcode has joined #ocaml
tobiasBora has joined #ocaml
gnuvince has joined #ocaml
eikke has quit [Ping timeout: 256 seconds]
chrisdotcode has quit [Quit: No Ping reply in 180 seconds.]
chrisdotcode has joined #ocaml
gnuvince has quit [Ping timeout: 252 seconds]
chrisdotcode has quit [Ping timeout: 248 seconds]
ttamttam has left #ocaml []
testcocoon has quit [Quit: Coyote finally caught me]
eikke has joined #ocaml
wmeyer has joined #ocaml
rudi2 has quit [Ping timeout: 256 seconds]
testcocoon has joined #ocaml
Yoric has joined #ocaml
rwmjones has quit [Read error: Operation timed out]
jcao219 has quit [Ping timeout: 256 seconds]
rwmjones has joined #ocaml
<wmeyer>
good evening
ggherdov has quit [Read error: Operation timed out]
lopex has quit [Ping timeout: 256 seconds]
IbnFirnas has quit [Ping timeout: 252 seconds]
<tobiasBora>
good evening ^^
<wmeyer>
tobiasBora: hi :-)
emmanuelux has joined #ocaml
<tobiasBora>
Hi ;-)
<tobiasBora>
Did you find some help for your project ?
<tobiasBora>
wmeyer: Apparently no ^^
<wmeyer>
tobiasBora: it does not matter really, in Oct def-lkb said he wants to help, I'll just wait
<wmeyer>
the problem here is that I found this project exciting, but it's not in my graphic at the moment
<wmeyer>
because it will simply not fit in my time scale
<tobiasBora>
You mean you don't have enough time ?
<wmeyer>
there are other nice things to do too in OCaml too, which are more important :-)
<wmeyer>
tobiasBora: yes, indeed ...
<tobiasBora>
Like ?
<wmeyer>
various bits & pieces
<tobiasBora>
You are on official contributor ?
<wmeyer>
well, i am talking about the whole OCaml community, libraries, coding in OCaml etc.
<wmeyer>
it's not really about OCaml itself that much :-)
<wmeyer>
tobiasBora: how is your learning?
<tobiasBora>
Ok. I've a question which interrogate me for a while : why by default a variable is constant ? Is it for technical reasons or for "ethic" ?
<wmeyer>
I hope you find OCaml pleasant
<wmeyer>
so the reason for that, is that it's a named value :-) and not variable
<wmeyer>
it's just named binding
<wmeyer>
nothing more
<wmeyer>
variable is a bit broaded and different concept, variable is named placeholder for value (like in C)
<wmeyer>
all of the technical, ethic, methodlogical, religious and conceptual reasons apply here
<wmeyer>
:-)
<tobiasBora>
wmeyer: Before I learnt more classical languages, like C++, PHP... and I played with elisp (but I didn't find a nice tutorial so I was very hard for me ^^), and this year I need to program in Ocaml. At the beginning I found it very strange and heavy to use, but know I begin to enjoy this language... Nearly more than a C++ !
<wmeyer>
but also you see we don't need that much variables
<wmeyer>
tobiasBora: great! keep it going. So for me C++ was the primary language for a long time.
<wmeyer>
my background is C++
<wmeyer>
and found OCaml way better
<wmeyer>
my impression was the same
<tobiasBora>
I see... And why "variables" are written as constant ? I found this system a bit disturbing : when we use let it create a new instance but keep the old one...
<tobiasBora>
wmeyer: And why did you begin to use Ocaml ?
<wmeyer>
well, because they are not constant, but they are values
<wmeyer>
if you want to mutate something you have to do it in a placeholder
<wmeyer>
so there is a special value that allows to mutate the contents
<tobiasBora>
What's the good name for "constant" in ocaml ?
<wmeyer>
it's called ref value and have polymorphic ['a ref] type
<tobiasBora>
(with let...=
<Drup>
tobiasBora: in what sense "heavy" ? I'm curious as Ocaml was my first langage, so I didn't have to do a transition from another paradigm (like C++).
<gasche>
the concept of "value" is of paramount importance in functional programming language
<wmeyer>
tobiasBora: I'd not be specific abput constant, and rather think about ref cells as being special
<gasche>
if there is a consensus among those, it is that the most concepts we present as "values", the better
<gasche>
(syntactically that goes by "everything in expressions")
<tobiasBora>
Drup: A lot of actions seems "heavy", the first one is that's it's difficult to use variable, and Ocaml seems to be between function and imperative language (I'm right or not ?)
<gasche>
a mutable variable is not first-class: you cannot pass it as a function argument and expect its mutation in the body to affect the passed variable
<gasche>
in contrast, an OCaml reference, being a "value", can be passed to a function, stored anywhere, etc.
<Drup>
tobiasBora: well, most of the time, you don't need variables ! :D
<tobiasBora>
Drup: An other is that I is not possible to surcharche functions... (And I find it really annoying ^^)
<gasche>
"surcharche" exists in no language I'm aware of :)
walter|r has joined #ocaml
walter has quit [Ping timeout: 248 seconds]
<tobiasBora>
gasche: I understand... And that's why it's really easy to give a function as parameters (is it possible like this in C++ ?)
ontologiae has quit [Ping timeout: 260 seconds]
<gasche>
there is a reasonable syntax for anonymous functions since C++11
<wmeyer>
tobiasBora: so it's possible in C++, void foo(int & var);
<wmeyer>
you see, special annotation that tells you want to do this
<gasche>
but you have to compute the closure capture information by hand, afaik
<tobiasBora>
gasche: So what's the word... When we define " void print(int) = ", "void print(string)"... with the same name but differents types ?
<wmeyer>
gasche: also, you can't return closures, unless you plan to deallocate them
<gasche>
overloading
<tobiasBora>
Yes thanks ^^
<wmeyer>
gasche: I see the move to the right direction, however I worked on a C++ compiler, and it's just get worse
<wmeyer>
(from the compiler engineer point of view)
<tobiasBora>
So Ocaml cannot use overloading function, and it's a bit strange to use I think.
<gasche>
that's a fair criticism
<gasche>
on the other hand, syntactic overloading mixes badly with type inference
<wmeyer>
tobiasBora: the answer is: you have reasonable other abstractions
<Drup>
gasche: typeclass :p
<gasche>
type classes can be understood as an extension of syntactic overloading that allows abstraction
<Drup>
but you're right.
<tobiasBora>
wmeyer: like ?
<wmeyer>
tobiasBora: oh pick anything you have in OCaml that C++ doesn't have.
<tobiasBora>
With sum type, we must call it with (S "hello") so it's not as overloading as (=)...
<Drup>
of course.
Yoric has quit [Ping timeout: 246 seconds]
<Drup>
but you're confusing a bit "overloading" with polymorphism. overloading is two function with the same name and the compiler decide which function is called based on the type of the argument. Polymorphism is defining *one* function that can take an argument of any type.
<tobiasBora>
And (=) is used with typeclasses ? Is it hard to do ?
<Drup>
There is no typeclass in ocaml.
<tobiasBora>
Oh yes you are right...
<tobiasBora>
Oh ok ^^ So how is build (=) ?
<wmeyer>
so it has a polymoprhic signature, but the comparision is done based on the runtime representation, and it's written in C.
<tobiasBora>
Ok. And this kind of features can be imagine in a futur version of Ocaml or we will always need C for more complex functions ?
<wmeyer>
there will be always runtime written in lower level language like C
<wmeyer>
and these polymorphic relations are so fundamental, that they deserved to be written in C (if we had overloading it will be also written in C for the primitive types)
<tobiasBora>
wmeyer: But I heard that ocaml has a compiler written in Ocaml. So this compiler compiles C too ?
ttamttam has joined #ocaml
ttamttam has quit [Remote host closed the connection]
<wmeyer>
it's written in OCaml, but the bytecode or native compiler is just a translator. The system also needs portion of code that is responsible for running the compiled code
<wmeyer>
and usually this requires lower level language then the one being compiled
<wmeyer>
or bootstraping (or both)
<wmeyer>
so no, the compiler does not compile to C, but C can call OCaml and OCaml and call C.
<wmeyer>
it compiles to the native assembly
<wmeyer>
or bytecode
gnuvince has joined #ocaml
Kakadu has quit []
<tobiasBora>
wmeyer: Thanks and lot for this explanations !
<tobiasBora>
*these
<wmeyer>
tobiasBora: you are welcome :-)
awm22 has quit [Quit: Leaving.]
<tobiasBora>
My bed is calling me... Goodnight and thanks for yours explanations, it's very interesting ;-)
awm22 has joined #ocaml
tobiasBora has quit [Quit: Konversation terminated!]
ontologiae has joined #ocaml
<bernardofpc>
Polymorphism is defining *one* function that can take an argument of any type. -> any type or a "'a TYPE" ?
<Drup>
bernardofpc: the description is indeed a bit quick :)
<bernardofpc>
In some sense, for me a function like map (::'a list -> ('a -> 'b) -> 'b list) is the simple polymorphism we get in OCaml
<bernardofpc>
maybe there's a more complex polymorphism possible ?
dsheets has joined #ocaml
<Drup>
I'm not sure to see your point about "any type" vs "a type".
ontologiae has quit [Ping timeout: 252 seconds]
<bernardofpc>
I meant <quote> 'a type </quote>
<wmeyer>
bernardofpc: that's what typeclasses do, they restrict polymorphism. We got the limited way of restricting via. subtyping.
<bernardofpc>
wmeyer: do you have an example of typeclasses ?
<Drup>
bernardofpc: oh, sure. Well, 'a is any type =)
<bernardofpc>
Drup: right, *but* you need to provide ('a -> 'b) in order to continue
<wmeyer>
what I really mean here, is that you can say that the function is defined on a range of types, where the range is defined by the type class instances
<bernardofpc>
so the polymorphism is "restricted" by giving a "true" function that "understands" your data, and that function is not polymorphic (at least not in the same level) as far as I understand
<wmeyer>
in case of polymoprhic variants, you can say that we are interested in the type that is exact, or a supertype
<Drup>
bernardofpc: in List.map, yes. That's just an example.
<bernardofpc>
Drup: I get the feeling that most 'a -stuff functions need a "helper" function that knows how to decode the 'a
<bernardofpc>
wmeyer: I don't understand what a type class is :/
<bernardofpc>
(how you could *define* that type class, for instance)
<wmeyer>
bernardofpc: OK, sorry. So the type class defines an interface under some name. It's a Haskell feature and is not present in OCaml.
<bernardofpc>
oh
<wmeyer>
When you have that interface, say treat it as module type
<wmeyer>
this interface has common name and a placeholder variable, that will contain the type
<Drup>
bernardofpc: you should see 'a as un unknown type, not really as a type of something that you don't know.
<bernardofpc>
interfaces like in the JAva meaning of interfaces ?
<Drup>
(not sure if I'm clear on this)
<wmeyer>
then you specialise the type class via instance by filling this variable for the concrete type and provide an implementation for the interface, specialised for this type
<wmeyer>
then, the program would be a collection of these instances
<wmeyer>
when your function uses that type class, it get's the annotation saying what kind of type class it is, but does not say for what type (the place holder contains a type variable)
ggherdov has joined #ocaml
<wmeyer>
and the function can use that interface now, and is overloaded for that collection of instances
dsheets has quit [Quit: Leaving]
<wmeyer>
so let's say I implemented a Show type class for my type that is an XML node
<wmeyer>
the Show type class is an interface that prints the value of tyhe type to string
<wmeyer>
now I got my XML data type
<bernardofpc>
let myxml = ...
<wmeyer>
and just provide an instance that defines how i want to pretty print this data type
<wmeyer>
I say it's an instance of Show class
<wmeyer>
and implement the needed interface
<wmeyer>
then I will have another data type, Json that defines json
<bernardofpc>
oh, data type, not data "value", sorry, ok
<wmeyer>
and also implement different pretty printer for this data type, this time in Json syntax
<wmeyer>
this is also Show type class instance
<bernardofpc>
I see
<wmeyer>
all the functions in Show type class need filling out
<bernardofpc>
then you can Show myxml ; Show myjson ; ?
<wmeyer>
once I implemented the instances for both types
<wmeyer>
yes
<wmeyer>
i am able to define a function that will not know if it's Json or XML but will be able to use any of the functions defined in the Show interface
<wmeyer>
it will be restricted overloading to instances of Show
<wmeyer>
there will be a lot of different instances of Show
<wmeyer>
for each type we want to be able to pretty print
<wmeyer>
and each of these can be passed to the function that uses them
<bernardofpc>
an instance of Show is a value of type XML / Json, or the Types themselves ?
<wmeyer>
let's say this function will pretty print to the file not to string
dsheets has joined #ocaml
<wmeyer>
it's a special type, in fact it's a family of types that range on everything that is Showable
ggherdov has quit [Changing host]
ggherdov has joined #ocaml
ggherdov has quit [Changing host]
ggherdov has joined #ocaml
<wmeyer>
so in Haskell, we say: [prettyPrintToFile :: Show a => String -> a -> IO ()]
<wmeyer>
you see double arrow?
<bernardofpc>
I see
<wmeyer>
this means that the this is for type class not for type
<bernardofpc>
oh
<bernardofpc>
(The String in the beginning is the file name, I presume)
<bernardofpc>
(the IO () afterwards is for Haskell side effects, guessing again)
Anarchos has quit [Quit: Vision[0.9.7-H-090423]: i've been blurred!]
<wmeyer>
bernardofpc: yes, you are right
<bernardofpc>
And for a Type to be Show-able, it has to offer a method (or something equivalent) that has a signature a -> string ?
<wmeyer>
the String is for the file name, and IO is for the side effect
<bernardofpc>
is the name of this method fixed ?
<wmeyer>
yes, it will offer a method for it, exactly as you said
<wmeyer>
and it will be implicit, you don't need to qualify it
<wmeyer>
it will be just there
<wmeyer>
implicitly opened
<bernardofpc>
right
<bernardofpc>
nice
<bernardofpc>
thanks a LOT !
<wmeyer>
bernardofpc: you are welcome :-)
<wmeyer>
btw: unless somebody will come up with something really robust, the type classes will be the missing feature for now.
<wmeyer>
it requires a lot of considerations in OCaml, as we have already a lot of features. There were some proposals
<wmeyer>
(good proposals)
<wmeyer>
but of course somebody then needs to just focus on getting that implemented in OCaml setting
<wmeyer>
it's a really wanted feature, so maybe someday
<bernardofpc>
I see
gnuvince has quit [Ping timeout: 245 seconds]
<wmeyer>
can't speak for other people, but it would be really good to have
<wmeyer>
and problem with polymorphic relations out of mind maybe, possibly type level computation as a bonus
lopex has joined #ocaml
<wmeyer>
there was some presentation on that by Pierre Chambart, and there is hope that after that get's implemented fully we might have the type classes in OCaml
ollehar has joined #ocaml
IbnFirnas has joined #ocaml
testcocoon has quit [Quit: Coyote finally caught me]
testcocoon has joined #ocaml
RagingDave has quit [Quit: Ex-Chat]
cdidd has quit [Ping timeout: 252 seconds]
<wmeyer>
dsheets: maybe next week we will have better luck of going to pub? :-)
<dsheets>
yeah
<dsheets>
we could go tomorrow
<dsheets>
or monday
<wmeyer>
OK!
<wmeyer>
tomorrow 3PM Cambridge Blue?
<dsheets>
most of the people i know in cambridge are in nyc
<dsheets>
sure one sec
<dsheets>
wmeyer, let's do it. i'll figure out how to pilot my bicycle to there
<wmeyer>
I have to be there at 2 PM though, but I can walk out for you
<wmeyer>
they have great selection, you will never get bored
<dsheets>
you *have* to be there at 2?
<wmeyer>
so, tomorrow, I will play chess at 2
<dsheets>
should i not come at 2? chess at the pub?
<wmeyer>
no no, please come whenever you wish, but I will play at 2 PM in the same pub
<wmeyer>
we can always go somewhere else or pick a different date
<wmeyer>
it does not matter, although tomorrow sounds really good to me
<dsheets>
ok, i'll be there around 2-3. i guess #ocaml can come, too?
<wmeyer>
monday is fine
<wmeyer>
sure!
<wmeyer>
bring as many people as you like
<dsheets>
oh, like i said, they are all in nyc, afaik
<wmeyer>
what's up with nyc?
<dsheets>
jane street
<dsheets>
some meeting
<wmeyer>
oh, ok, well, you know i do think there will be always some occasion to meet later
jcao219 has joined #ocaml
<dsheets>
i installed my ssd today and it's great
<wmeyer>
so no worry
<wmeyer>
great, i got my toy today too :-)
<wmeyer>
how big is your ssd?
cdidd has joined #ocaml
<dsheets>
also, proper font rendering is really nice and makes me surprisingly happy for the amount of change and difficulty
<wmeyer>
i do believe it's a future
<dsheets>
256gb, samsung 840 pro
<wmeyer>
great, i like ssd to be honest :-)
<dsheets>
520mb/s read, 900mb/s write
<wmeyer>
since my hard drive broke some time ago, and i don't trust hard drives really
<wmeyer>
but ssd is fine
<dsheets>
Now I just have to figure out how to conserve cycles... it's been bothering me all day. I need to figure out how to make opam build on a tmpfs and then transfer the results into it's working copy
<wmeyer>
yeah, and it's small, and don't do any noise
<dsheets>
yes, the boot time is amazing
<dsheets>
moved my hdd into the optical bay
<dsheets>
what's your new toy?
<wmeyer>
Chromebook
<dsheets>
ooo
<dsheets>
does it run ocaml, yet?
<wmeyer>
unpacking Ubuntu at the moment
<wmeyer>
well AC100 used to run 8-)
<dsheets>
did you get the pixel one?
<wmeyer>
that one is just ARM based
<wmeyer>
the cheap and good one, the pixel one looks good but was much bigger, in terms of size and the price
<wmeyer>
someday maybe
<dsheets>
ah, yes, ok
<wmeyer>
google/samsung gets the right quality/price ratio :-)
<dsheets>
i don't know what the touch part is for
<wmeyer>
i don't know either
<wmeyer>
I still need to compile Common Lisp on my arm book
<dsheets>
a different arm book?
<wmeyer>
the same
<wmeyer>
will bring tomorrow, maybe
ontologiae has joined #ocaml
<wmeyer>
(nothig special though; they get popular very quickly!)
tlockney has joined #ocaml
<dsheets>
ok, sounds good. i will probably bring my thinkpad. now, time for dinner! see you tmrw
<wmeyer>
see you, there :-)
eikke has quit [Ping timeout: 264 seconds]
gnuvince has joined #ocaml
eikke has joined #ocaml
Tobu has joined #ocaml
<ollehar>
anyone awake? need a tutorial, or something, to get merlin running.