ygrek has quit [Remote host closed the connection]
lopex has joined #ocaml
shinnya has quit [Ping timeout: 264 seconds]
ygrek has joined #ocaml
hsuh has quit [Ping timeout: 256 seconds]
hsuh has joined #ocaml
hsuh has quit [Ping timeout: 256 seconds]
hsuh has joined #ocaml
nojb has joined #ocaml
mcc has joined #ocaml
<mcc>
whitequark: re: twitter complaining, what do you suppose "The type constructor macroSpec would escape its scope" means?
<whitequark>
hrm
<whitequark>
are you using first-class modules or GADTs?..
<mcc>
I am not using either as far as I know, and the file is quite compact.
<mcc>
Here, one second.
<mcc>
https://gist.github.com/mcclure/e76ae846d6d7de7a5b4a It is a pretty short file, although "process" is unpleasantly dense and uncommented. Sorry :( The problem is line 30, macroSpec is defined above and appears in no other file.
<mcc>
I don't use "open", because it's terrifying.
<whitequark>
whoa, that's fascinating.
<mcc>
The error message?
<whitequark>
yes.
<mcc>
I'm guessing it's a really elaborate way of saying "Syntax error" :(
ygrek has quit [Ping timeout: 240 seconds]
<whitequark>
no.
<whitequark>
it's not a syntax error, it's not C++ where semantic analysis and parsing are interspersed
<whitequark>
the thing is, you shouldn't possibly get that error O_o
<whitequark>
it arises from existentials, i.e. from GADTs and first-class modules
hsuh has quit [Ping timeout: 255 seconds]
<whitequark>
let me stub it a bit
<mcc>
ok D: um, do you want the context commit?
<whitequark>
wow, it really gives that error
<whitequark>
no, I already stubbed it out
<mcc>
ew D:
<mcc>
do you know what i did to provoke the error?
<whitequark>
hang on, it's so unusual that I can't guess the reason for an error, it's a bit exciting
<mcc>
hahaha
<whitequark>
don't spoil it just yet
hsuh has joined #ocaml
<mcc>
ok
<mcc>
By the way, is it REALLY a desirable behavior that using Macro.x inside the Macro module is a recursive reference error
<whitequark>
yes
<whitequark>
imagine if x was defined after current line
<whitequark>
then it would be uninitialized.
<whitequark>
if Macro is not in scope however, all uninitialized identifiers are also not.
<mcc>
*thinks* ok
<whitequark>
incidentally, did you know you can short things like match x with {foo=foo} -> to just {foo} -> ?
<whitequark>
and ~foo:foo to ~foo
<mcc>
no; i was actually just sitting here wishing this feature existed :
<mcc>
:P
<whitequark>
it's called "commuting" and makes the code quite a bit more readable
<whitequark>
ok
<mcc>
thanks!
<whitequark>
OH
<whitequark>
...
<whitequark>
I...
<mcc>
this… this syntax has a LOT of features.
<whitequark>
figured it out
<mcc>
Oh :O what's wrong?
<whitequark>
wow.
<whitequark>
it was NOT obvious.
<mcc>
is it the parenthesis i bet it's the parenthesis
<whitequark>
no.
<whitequark>
the minimal example is:
<whitequark>
let t = Hashtbl.create(1)
<whitequark>
type u = { v : unit -> unit }
<whitequark>
let f () = let {v} = Hashtbl.find t "" in ()
<mcc>
uh oh
<whitequark>
you can actually guess what's wrong already
<whitequark>
if you think about the message
<mcc>
I am not guessing what is wrong D: Does parameterizing on hashtbl create a different kind of type somehow?
<mcc>
i.e. did i somehow autoinstantiate a Hashtbl.u or something
<whitequark>
nah
<whitequark>
do you remember what type would `t` be if you just had that one line?
<whitequark>
we discussed it here before.
<mcc>
a ('a,'b) Hashtbl, I think
<whitequark>
that's almost true
<whitequark>
remember that a hash table is mutable
<mcc>
I still don't know what the problem is; is the solution to type macroTable more specifically?
<mcc>
hm
<mcc>
is that relevant to types?
<whitequark>
yes
<mcc>
bother
<whitequark>
well, try it out in toplevel
<whitequark>
# let t = Hashtbl.create(1);;
<whitequark>
val t : ('_a, '_b) Hashtbl.t = <abstr> #
<whitequark>
so, that's all fine and good
<whitequark>
but in let f, you constrain that '_b to be u
<whitequark>
so that at the point of definition, t actually becomes of type (string, u) Hashtbl.t...
<whitequark>
... except u doesn't exist yet
<mcc>
D:
<whitequark>
put type u before let t to fix it
<whitequark>
I applaud you on finding the most cryptic error message I have ever seen in OCaml, and even with such a trivial example
nojb has quit [Ping timeout: 252 seconds]
<whitequark>
it takes not even skill. it is art
<mcc>
hahaha
<mcc>
oh god
<mcc>
yes, moving macroTable downward in the file fixed it :(
<mcc>
Is this … is this the second or the third Mantis error you've filed on my behalf
<whitequark>
fourth, iirc
<whitequark>
maybe third?
<mcc>
plausible
<whitequark>
I mean
<whitequark>
I reported sixty.
<mcc>
Hahaha
<whitequark>
I wrote a patch for twelve.
<mcc>
Right, right. But four had a chain of causaility that started with me not understnading what i'm doing
<mcc>
anyway i will endeavor to top this one
<mcc>
thank you as always for the help :O
<whitequark>
sure
<mcc>
As a general comment on language design more than an attempt to pass a value judgement on ocaml:
<mcc>
I feel like I have been encountering a LOT of moments where understanding what is happening / what to do / what an error message means fundamentally depends on understanding how the compiler works.
<mcc>
I feel like this is a flaw in a language.
<mcc>
Probably a hard to avoid flaw, but a flaw.
<whitequark>
I recognize your position, but I think it is flawed
<whitequark>
it depends on understanding how the *language* works, more specifically its type system
<whitequark>
I mean, it seems complex. It's not complex at all if you actually look at the sources of the goddamn typechecker
<mcc>
i will concur it seems to be an unusually comprehensible compiler
<whitequark>
ahem. regardless of the last remark, yes, understanding the semantics of the language is necessary.
<whitequark>
OCaml doesn't even have a lot of moving parts, in comparison to others.
<mcc>
i remind you i am primarily a c++ programmer
<mcc>
my watermark is GCC
<mcc>
...
<whitequark>
there is a persistent notion that a typechecker is "necessary evil" and "part of compiler" that can be "flawed" and should be "avoided"
darkf has joined #ocaml
<whitequark>
yes, I'm sub... ircing C++ compilers and gcc in particular.
<mcc>
i started looking at clang and going "wow! the architecture is so simple and straightforward!". The sources are 700 MB
<whitequark>
a (well-designed) typechecker is your dear friend that will help you in rain and blizzard. love it!
<mcc>
i like types
<whitequark>
to concur, I agree that ocaml's error messages are not very good. there is ongoing work to make them more comprehensible
<whitequark>
but I do not think this is a flaw in the language.
* mcc
thinks. i feel like there's a finer distinction i want to make, but i don't know how to formulate it
<mcc>
By the way-- do you know, how is it that Merlin and ocamlopt came to emit different error messages?
<whitequark>
have you heard the phrase "puzzle aspect of the language"?
<whitequark>
all languages with a reasonable typesystem invariably come to contain a puzzle aspect, to some degree...
<mcc>
hah
<whitequark>
... it's in the eye of the beholder, in a way; you can write code in ocaml like you do in c, but ocaml actually offers you nice tools to manage complexity.
<whitequark>
so you feel compelled to use them, but the tools, specialized as they are, introduce the puzzle aspect.
<whitequark>
what draws me to ocaml is that its puzzle aspect is much limited. you don't need an IO monad. you don't use GADTs everywhere.
<whitequark>
GADTs are an absolute nosebleed of puzzle aspect!
<whitequark>
they essentially say to you: "nice semantics you have here. now, can you figure out how to map them to simply typed lambda calculus?"
<mcc>
so *thinks* i definitely think there are some tools where like...
<mcc>
people start to find the puzzle aspect rewarding in itself.
<mcc>
because puzzles are fun.
<whitequark>
yes.
<whitequark>
i think this is absolutely a major part of the haskell community, for example.
<mcc>
i… you said it, not me. but yes.
<mcc>
the problem is, you want the puzzles to map cleanly to *actual* puzzles in the problem your program is trying to solve...
<whitequark>
(and forth, to a degree)
<mcc>
but if the puzzle is something like "how do i express this in my language?"... that is bad. obviously, i guess
<whitequark>
well. in most languages, you can always defeat the puzzle the straightforward way
<whitequark>
wrap everything in IO monad in haskell. use process dictionary in erlang. switch to local variables in forth.
<whitequark>
but then you lose the very reason you use this particular language
<mcc>
heh
<mcc>
i think that's not *necessarily* what i'm thinking. i just... so any language, you build a mental model in your head of the machine which will be executing it.
<whitequark>
so the "how do i express it ELEGANTLY in my language" is inherent to languages
<whitequark>
"how do i map the domain the language is supposed to cover to my problem domain"
<mcc>
(one solution is the Perl approach, where all approaches are equally inelegant.)
<whitequark>
you could it call the essence of programming, if you will.
dmiles has joined #ocaml
kandu_ has joined #ocaml
<whitequark>
i feel like the "my problem domain" part doesn't get enough attention
<mcc>
but a language implementor obviously has a more sophisticated model in their head. because they are thinking not just about "well, the object is a thing that you can perform field lookups on to access members or methods", but they're also thinking about vtables.
<whitequark>
hrm
|jbrown| has joined #ocaml
<mcc>
but... but not really, because the user has to know about vtables too.
<mcc>
because they matter.
kandu has quit [Disconnected by services]
kandu_ is now known as kandu
<mcc>
i think i'm trying to suggest that there's some sort of firewall where the machine the user has in their head and the machine the implementor has in their head, maybe certain kinds of detail should not be flowing from the right side to the left side. (ignoring performance.)
jerith_ has joined #ocaml
<whitequark>
C++ is a famously leaky abstraction, yeah
<mcc>
C++ is a sieve. maybe it is a bad example for this reason.
<whitequark>
you won't ever need to think about ocaml's vtables, *especially* ignoring abstraction
<whitequark>
err
<whitequark>
ignoring performance
<mcc>
i didn't even know it had them.
<mcc>
but like... both ocaml and c++ seem to present machines which *appear* to have a level of simplicity which isn't actually the one you can get away with programming at.
<whitequark>
well, it has virtual dispatch!
<mcc>
i suppose it does
<whitequark>
(any runtime dispatch at all will do, in fact)
<whitequark>
so, hm
<whitequark>
what would be the place ocaml leaks, in your view?
<mcc>
This is a pretty vague comment.
<mcc>
well... in this case, and in most of the cases i have problems with ocaml, it seems like something is being presented where...
<mcc>
there's an easy mental model where i simply define a bunch of things.
cthuluh_ has joined #ocaml
<mcc>
i "let" all of these different things, and then execution sweeps through and they are all able to call each other.
<mcc>
in fact each line is altering an evaluation environment and i need to be aware of the state of that evaluation argument at all times.
<mcc>
err, evaluation environment.
<mcc>
and like, the whole thing does a good job of masking it to *some* degree, but then all this stuff comes up with no mutual recursion of modules, or of variables.
<mcc>
i feel like most of my problems with ocaml have actually been with managing mutual recursion and what it requires.
<whitequark>
actually your mental problem is very close to reality
<whitequark>
I mean, you even say "execution sweeps through"
<whitequark>
execution is directional, it proceeds from first line to last!
<mcc>
that is the problem. the model of the language requires me to be aware of reality.
<mcc>
however it's very easy to look at the language as a whole and like… just see this pristine platonic world where i should be able to define everything and the language figures it out, somehow.
<whitequark>
use haskell ;d
<mcc>
that's just not the language that actually exists.
<whitequark>
it can do that.
<whitequark>
(sorta)
<whitequark>
the thing that forces execution to appear sequential is side-effects.
<mcc>
you mentioned something about a constraint solver being needed for that to be possible. c++ and python manage to do it though by simply sacrificing performance and correctness
<whitequark>
the thing that produces the '_a is side-effects
<whitequark>
well, no, you have the exact same problem in python.
<whitequark>
def a: b def b: pass
<mcc>
well, haskell also has a solution, yes. although it has tha tprelude thing?
<mcc>
i am confused about what does and doesn't have to go in the prelude
<whitequark>
no, it has the constraint solver thing
<mcc>
oh.
kapil__ has joined #ocaml
<mcc>
anyway, i do get that this is a side effect problem, but an awful lot of my ocaml code doesn't *have* side effects.
<whitequark>
you can't really fix this unless you forbid *all* side effects *everywhere*
<mcc>
so, consider how for example Java solves this.
<whitequark>
Java also has this problem! try creating an instance of a class within a static initializer.
<mcc>
There are two passes. One is basically declarative, one is basically imperative..
<whitequark>
or refer from one static initializer to another
<mcc>
hm
<mcc>
but you don't have to use the static initializers, right?
<mcc>
they have that class definition / static initializer world where you have the limitations of ocaml, and then you can segregate side-effects until "now the world is created" time
<mcc>
incidentally, are you sure python has that problem? I ran your code and it worked
<whitequark>
you can have that in ocaml by putting all your modules into a giant module rec block and all values into a giant let rec block
<mcc>
hm
<mcc>
ok, that's promising
<whitequark>
(by induction, all your code will have to be in a single giant .ml file)
ineol has joined #ocaml
<whitequark>
it's inelegant, which is an explicit design choice. it also restricts what types you can use, because some (mutually recursive) things can't go into a module rec block
<whitequark>
note that none of the things that become inaccessible in ocaml were ever expressible in, say, java
<mcc>
so i want to again stress i'm not talking about value judgements
dmiles_afk has quit [*.net *.split]
jerith has quit [*.net *.split]
myst|work has quit [*.net *.split]
jbrown has quit [*.net *.split]
cthuluh has quit [*.net *.split]
<mcc>
a set of tradeoffs were made and they had some advantages and some disadvantages
<whitequark>
exactly
<mcc>
i *am* curious if there is a less frustrating way ocaml could have done this while preserving ocaml's spirit, but whatever
<whitequark>
I can't really answer this, since I find it convenient rather than frustrating
<whitequark>
and thus unable to judge any alternative
<mcc>
sure
<mcc>
but i was to start making a SUPER vague point, which is that this was really just an example of needing to think about "but how is it executed?" and not "but what do the constructs do?"
<whitequark>
yes, the point in my reply is that the two aren't distinct
lordkryss has quit [Quit: Connection closed for inactivity]
<mcc>
I'm trying to grope for a way of formulating this in a distinct way.
<mcc>
Which: Yes, in the specific case of recursion, the "but how is it executed?" really is inextricable from the question of "what does the language mean?"
<mcc>
The other example, vtables, is poor for a totally different reason, which is that c++ is garbage and it is easy to dismiss that as "well, c++ is garbage"
<whitequark>
umm
<mcc>
sorry. let me rephrase that: vtables which the user needs to be aware of.
<mcc>
and needs to be careful not to accidentally overwrite.
<whitequark>
no, I mean, both "how is this executed?" and "what does it mean?" really refer to language semantics
<mcc>
AND THE FACT THAT YOUR LANGUAGE HAS TOTALLY DIFFERENT REIFICATION AND BEHAVIOR DEPENDING ON THE PRESENCE OR ABSENCE OF AT LEAST ONE VIRTUAL METHOD.
<whitequark>
I fail to grasp the fine distinction, I guess.
<mcc>
I think I'm failing to formulate it well. Let me get back to you in a couple of years when I've thought about it some more :P
<whitequark>
it's not that, say, it's a machine-specific detail. it's a fairly fundamental question of "what happens if i refer to an uninitialized value"
<whitequark>
or rather "undefined value"
<mcc>
sure
<whitequark>
so I think what you're getting at here, maybe, is that some constructs *look* declarative
<mcc>
Maybe the thing I am trying to really grope for is, the frequency by which the semantics of a language construct are motivated by a implementation design choice.
<whitequark>
and independent of the others
<whitequark>
let kind of does
<mcc>
You see this a lot in, say, Javascript.
<whitequark>
you can reorder them, etc.
<whitequark>
but they aren't, unlike in some other popular languages.
<mcc>
"Why does X work Y way" "Because Internet Explorer 7 decided to implement X in Z way, so that made it behave like Y"
<whitequark>
*nod* that's a different question, one I wouldn't have any issues with
<mcc>
ocaml maybe escapes this in the case of the mutual recursion issues because the answer isn't "we decided not to implement a solver" but rather "because the files containing declarations are actually code sequentially executed, and we must guarantee an explicit sequencing"
<mcc>
which is kind of… there's some extent to which this is motivated in terms the user cares about. the user doesn't care about "...because we decided to use a refcounting gc"
<mcc>
on the other hand, maybe 90% of the time i don't care, or i wish i didn't have to care, about execution order at the toplevel :P
<whitequark>
I don't think you're correct, let me put it another way
<whitequark>
it doesn't even matter how they're *executed*
hsuh has quit [Ping timeout: 272 seconds]
<whitequark>
it matters how they're *defined*. it's inherent in the lexical structure of the language.
<whitequark>
before "let x" x is not defined. after "let x" (or "let x in") x is defined
myst|work has joined #ocaml
<whitequark>
you're arguing for semantics which allows some kind of defined but not initialized variable
<whitequark>
ocaml says that there is no such thing ever, because there are no uninitialized variables in its semantics.
<whitequark>
"before" and "after" here really refers to the lexical structure of the language itself, not even the abstract machine
<whitequark>
you can't *mention* a type t or variable v lexically-before the place you define it
<whitequark>
so, it is true that, say, C++ doesn't have this restriction (mostly; note how you still have to define everything if you want mutual recursion. that is not an accident)
<mcc>
right
<mcc>
however, i mostly work in completely unsafe languages where everything is nullable :)
<whitequark>
mcc: so, you could actually take the convention from C++ and put it into ocaml. you will have to either give up on type safety, or add some trap value for not-yet-initialized variables
<mcc>
so of course i'm going to notice when the flexibility that affords disappears
<mcc>
yeah
<whitequark>
but that's not really the most important loss
ineol has quit [Quit: ineol]
<whitequark>
you lose the ability to shadow things in the toplevel
<whitequark>
and you lose the structural similarity of toplevel with non-toplevel
<mcc>
yes. i like the lack of preludes
<whitequark>
so, python, right? before you first assign to a local variable, it is still defined in the scope, and would raise an exception on access
hsuh has joined #ocaml
<whitequark>
and you get the *same behavior* on toplevel
<mcc>
yes.
<whitequark>
ocaml does this *neither* in toplevel *nor* inside a function
<whitequark>
both approaches are conceptually consistent.
marynate has joined #ocaml
<whitequark>
C, uhrmmm, follows what OCaml does, but allows you to pre-declare the function or variable, whether at toplevel or inside a function.
<mcc>
so i ... assume i'm really thinking about all this because i'm thinking about the "what would i do if i designed a language" question.
<whitequark>
*nod*
<mcc>
and i feel like the fundamental issue here is i do not always want the same thing.
<whitequark>
*nod*
<mcc>
sometimes i want safety and sometimes i just want it to work and i don't care.
<mcc>
i feel like an ideal language would allow me, somehow or other-- not on this particular issue but just in general-- to somehow just indicate what i want, and tell me whether i got it or not.
<mcc>
so like, consider perl.
<whitequark>
that's not impossible to do.
<whitequark>
but it results in a language with many moving parts, which, if even implemented perfectly, is still confusing to users
<mcc>
you mentioned the idea of "this can be referenced, but it has not been defined yet"
<whitequark>
like, why is there a switch that changes toplevel from declarative to imperative?
<whitequark>
what are the best practices for using it?
<mcc>
whether this exists or not in perl is based on the presence of 'use strict;"
<whitequark>
why does my linter complain about it?
<whitequark>
EXACTLY
<mcc>
now, this is also not a great example, because no one ever turns use strict off.
<whitequark>
also wow that's horrible.
<mcc>
but, it is an example of *a* language allowign this.
<mcc>
yeh. basically "use strict" institutes a series of language features that you'd never want to turn off.
<mcc>
...well, unless you are my girlfriend, who claims to actually prefer python's variable semantics.
<mcc>
anyway.
<mcc>
i think what i'm imagining is "does it need to exist yet or not" might be possible on a per-variable basis.
<mcc>
although i'm not sure i can write syntax/rules for that that aren't more complicated than just "just… don't do mutual recursion" or something.
<mcc>
anyway speaking of my girlfriend, i think we're gonna go eat dinner now. talk to you later :O
<whitequark>
o/
<mcc>
^_^
hsuh has quit [Ping timeout: 264 seconds]
hsuh has joined #ocaml
<Drup>
mcc: one way not to care, is to take the haskell route
<Drup>
being lazy for everything work around a lot of this problems
<Drup>
(by creating a shitload of other problems)
hsuh has quit [Ping timeout: 245 seconds]
hsuh has joined #ocaml
enitiz has joined #ocaml
oscar_toro has quit [Ping timeout: 265 seconds]
araujo has quit [Ping timeout: 245 seconds]
samrat has joined #ocaml
enitiz has quit [Ping timeout: 244 seconds]
araujo has joined #ocaml
struktured has joined #ocaml
samrat has quit [Quit: Computer has gone to sleep.]
struktured has quit [Quit: Konversation terminated!]
seangrove has quit [Ping timeout: 272 seconds]
alkoma has joined #ocaml
mcclurmc has joined #ocaml
BitPuffin has quit [Ping timeout: 244 seconds]
samrat has joined #ocaml
PryMar56 has quit [Quit: Leaving]
govg has joined #ocaml
govg is now known as Guest2291
samrat has quit [Quit: Computer has gone to sleep.]
artagnon has left #ocaml [#ocaml]
Guest2291 has quit [Quit: leaving]
govg_ has joined #ocaml
samrat has joined #ocaml
ygrek has quit [Ping timeout: 240 seconds]
govg_ has quit [Read error: Connection reset by peer]
govg has joined #ocaml
psy has quit [Read error: Connection reset by peer]
psy has joined #ocaml
psy has quit [Read error: Connection reset by peer]
psy has joined #ocaml
ygrek has joined #ocaml
mcclurmc has quit [Remote host closed the connection]
mcclurmc has joined #ocaml
mcclurmc has quit [Ping timeout: 245 seconds]
ggole has joined #ocaml
mcc has quit [Quit: This computer has gone to sleep]
mcc has joined #ocaml
samrat has quit [Quit: Computer has gone to sleep.]
kapil__ has quit [Quit: Connection closed for inactivity]
rgrinberg has quit [Quit: Leaving.]
<def`>
mcc: which error was different in merlin and ocaml?
govg has quit [Quit: leaving]
govg has joined #ocaml
samrat has joined #ocaml
govg has quit [Ping timeout: 245 seconds]
axiles has joined #ocaml
mcc has quit [Quit: This computer has gone to sleep]
kapil__ has joined #ocaml
thorsten1 has quit [Quit: WeeChat 1.1-dev]
thorsten` has joined #ocaml
psy has quit [Ping timeout: 255 seconds]
chinglish has joined #ocaml
ente has joined #ocaml
<ente>
'lo
<adrien>
hi :)
<ente>
adrien!
<ente>
31c3? :)
<adrien>
definitely
kakadu has joined #ocaml
<ente>
perfect!
<adrien>
planning will be a bit tight: we're getting to hamburg by plane on tomorrow and landing is a bit after 10am
psy_ has joined #ocaml
<adrien>
still need to pack and write down where we're supposed to sleep
<ente>
I'm leaving in 3h
<ente>
going by train, spent all night trying to get UMTS work
<ente>
query? I don't feel comfortable knowing I just joined here and I'm already taking things OT :)
<adrien>
heh
<adrien>
sure but in any case it's fine since there's 0 activity otherwise right now
<ente>
I've been scoffed at for pasting 5 lines of (buggy) code into an otherwise idle channel ;)
<adrien>
hah :)
<adrien>
#ocaml isn't #c :P
<adrien>
(although I guess that wasn't C)
<ente>
I found bug in someone's C code, but no, not #c
<ente>
+the
<ente>
I intentionally pasted the code to the channel because I figured pasting 5 lines to a pastebin and posting a link just so everybody has to click on it would be overkill
<ente>
apparently someone thought I was wrong ;)
waneck has quit [Ping timeout: 240 seconds]
<adrien>
heheh, it's fine here (well, unless your lines are 200-chars wide)
alkoma has quit [Remote host closed the connection]
kakadu_ has joined #ocaml
kakadu has quit [Quit: Page closed]
kakadu_ has quit [Remote host closed the connection]
kakadu has joined #ocaml
larhat has quit [Quit: Leaving.]
_andre has joined #ocaml
Simn has joined #ocaml
tharugrim has quit [Ping timeout: 244 seconds]
rgrinberg has joined #ocaml
tharugrim has joined #ocaml
Submarine has joined #ocaml
milosn has quit [Remote host closed the connection]
rgrinberg has quit [Quit: Leaving.]
rgrinberg has joined #ocaml
rgrinberg has quit [Client Quit]
nojb has joined #ocaml
nojb has quit [Client Quit]
zozozo has joined #ocaml
ygrek has quit [Ping timeout: 256 seconds]
govg has joined #ocaml
tane has joined #ocaml
ontologiae has joined #ocaml
nojb has joined #ocaml
oscar_toro has joined #ocaml
marynate has quit [Ping timeout: 255 seconds]
marynate has joined #ocaml
nojb has quit [Quit: nojb]
ineol has joined #ocaml
nojb has joined #ocaml
marynate has quit [Read error: Connection reset by peer]
marynate has joined #ocaml
marynate has quit [Ping timeout: 252 seconds]
marynate has joined #ocaml
milosn has joined #ocaml
larhat has joined #ocaml
marynate has quit [Ping timeout: 255 seconds]
marynate has joined #ocaml
psy_ has quit [Remote host closed the connection]
nojb has quit [Quit: nojb]
kapil__ has quit [Quit: Connection closed for inactivity]
nojb has joined #ocaml
nojb has quit [Client Quit]
oriba has joined #ocaml
sol__ has joined #ocaml
AltGr has left #ocaml [#ocaml]
psy has joined #ocaml
kapil__ has joined #ocaml
samrat has quit [Quit: Computer has gone to sleep.]
cthuluh_ is now known as cthuluh
oscar_toro has quit [Ping timeout: 272 seconds]
oscar_toro has joined #ocaml
oscar_toro has quit [Read error: Connection reset by peer]
<nicoo>
ente: See, this is off-topic too! (Also, why are you named “duck”?)
tane has quit [Read error: Connection reset by peer]
tane has joined #ocaml
<adrien>
they need a novena instead
tane has left #ocaml [#ocaml]
BitPuffin has quit [Quit: See you on the dark side of the moon!]
enitiz has quit [Ping timeout: 256 seconds]
kapil__ has quit [Quit: Connection closed for inactivity]
ontologiae has quit [Ping timeout: 250 seconds]
_5kg has joined #ocaml
BitPuffin has joined #ocaml
milosn has quit [Ping timeout: 245 seconds]
chinglish has quit [Ping timeout: 244 seconds]
chinglish has joined #ocaml
ontologiae has joined #ocaml
<ente>
nicoo: I don't really remember anymore
jao has joined #ocaml
jao has quit [Changing host]
jao has joined #ocaml
q66[lap] has quit [Changing host]
q66[lap] has joined #ocaml
milosn has joined #ocaml
enitiz has joined #ocaml
ontologiae has quit [Ping timeout: 245 seconds]
kakadu has quit [Ping timeout: 258 seconds]
struktured has quit [Ping timeout: 258 seconds]
araujo has quit [Ping timeout: 250 seconds]
kakadu has joined #ocaml
araujo has joined #ocaml
ebzzry has joined #ocaml
struktured has joined #ocaml
Bluddy has joined #ocaml
ygrek has quit [Ping timeout: 240 seconds]
ontologiae has joined #ocaml
nojb has joined #ocaml
troydm has quit [Ping timeout: 250 seconds]
kakadu has quit [Remote host closed the connection]
enitiz has quit [Ping timeout: 264 seconds]
troydm has joined #ocaml
chinglish has quit [Quit: Nettalk6 - www.ntalk.de]
malc_ has joined #ocaml
kakadu has joined #ocaml
davine has joined #ocaml
davine has left #ocaml ["Leaving"]
nojb has quit [Quit: nojb]
rgrinberg has joined #ocaml
mcc has joined #ocaml
Muzer has quit [Excess Flood]
MrScout has joined #ocaml
Muzer has joined #ocaml
rgrinberg has quit [Quit: Leaving.]
Submarine has quit [Remote host closed the connection]
girrig has joined #ocaml
govg has quit [Ping timeout: 264 seconds]
ingsoc has quit [Quit: Leaving.]
icicled has quit [Ping timeout: 258 seconds]
matason has joined #ocaml
alkoma has joined #ocaml
<struktured>
anyone know what the "builtin" make variable is in an opam config?
<whitequark>
opam config list
rgrinberg has joined #ocaml
rgrinberg has quit [Client Quit]
_andre has quit [Quit: leaving]
<struktured>
whitequark: thanks, the other thing I was missing is how to even reference them properly, which is simply use the variable name directly in the opam file instead of a string expression.
<whitequark>
yep
enitiz has joined #ocaml
anemator has joined #ocaml
anemator has quit []
NoNNaN has joined #ocaml
struktured has quit [Ping timeout: 265 seconds]
Hannibal_Smith has joined #ocaml
samrat has quit [Quit: Computer has gone to sleep.]
struktured has joined #ocaml
mcclurmc has quit [Remote host closed the connection]
malc_ has quit [Ping timeout: 245 seconds]
Submarine has joined #ocaml
Submarine has quit [Changing host]
Submarine has joined #ocaml
hilquias has joined #ocaml
axiles has quit [Remote host closed the connection]
ggole has quit []
mcclurmc has joined #ocaml
mcclurmc has quit [Remote host closed the connection]
mcclurmc has joined #ocaml
govg has joined #ocaml
matason has quit [Quit: leaving]
mcclurmc has quit [Ping timeout: 244 seconds]
mcclurmc has joined #ocaml
mcclurmc has quit [Ping timeout: 245 seconds]
icicled has joined #ocaml
nojb has joined #ocaml
nojb has quit [Client Quit]
nojb has joined #ocaml
nojb has quit [Client Quit]
govg has quit [Ping timeout: 244 seconds]
ontologiae has quit [Ping timeout: 244 seconds]
Hannibal_Smith has quit [Quit: Leaving]
Muzer has quit [Excess Flood]
Submarine has quit [Quit: Leaving]
Hannibal_Smith has joined #ocaml
Muzer has joined #ocaml
Muzer has quit [Excess Flood]
Muzer has joined #ocaml
rand000 has joined #ocaml
larhat has quit [Quit: Leaving.]
Bluddy has quit [Quit: Connection closed for inactivity]
MercurialAlchemi has joined #ocaml
keen__________14 has joined #ocaml
keen__________13 has quit [Ping timeout: 240 seconds]
nojb has joined #ocaml
nojb has quit [Ping timeout: 255 seconds]
enitiz has quit [Ping timeout: 240 seconds]
araujo has quit [Ping timeout: 258 seconds]
nojb has joined #ocaml
araujo has joined #ocaml
araujo has quit [Max SendQ exceeded]
araujo has joined #ocaml
Hannibal_Smith has quit [Quit: Leaving]
kakadu has quit [Remote host closed the connection]
nojb has quit [Quit: nojb]
AlexRussia has quit [Ping timeout: 244 seconds]
AlexRussia has joined #ocaml
jonludlam has joined #ocaml
MercurialAlchemi has quit [Ping timeout: 244 seconds]
enitiz has joined #ocaml
<struktured>
do build warnings on travis cause the compilation abort? trying to figure out why yet another one of my builds is faiing
<whitequark>
not without -warn-error
<whitequark>
the compiler will say if some warnings were turned to errors.