<Superpelican_>
I’m getting a syntax error on line 15
<pgomes>
I would say it requires a semi-colon
<pgomes>
in line 15 no ?
<oriba>
What is the "`name"-argument for in Tk-idgests (labltk) ? I remember, somehow, Tk had a signalling mechanism... does this argument it relate to it? And how to use it?
<oriba>
what does (ocamlnet) "Uncaught exception: Netconversion.Malformed_code" mean? Looks like an internal error, I did not use a Netconversion-module at all.
<rgrinberg>
oriba: did you turn on stack traces?
<oriba>
hmhh, stack traces? don't know that option. Is it compile-time or runtime switch?
<ggole>
Both
inr_ is now known as inr
<ggole>
Compile everything with -g, run with OCAMLRUNPARAM="b"
freling has quit [Ping timeout: 264 seconds]
<def`>
Superpelican_: the binding opened on line 3 is not terminated
<bernardo1pc>
Superpelican_: remove ; on line 5
<def`>
(the ; on line 5 … Ok)
<oriba>
ggole, done; does not print more information
avsm1 has joined #ocaml
Denommus has joined #ocaml
<Superpelican_>
bernardo1pc: thanks, I forgot
shinnya has joined #ocaml
<Superpelican_>
def`: what binding?
<def`>
Superpelican_: that's what bernardo1pc said
<def`>
the "let () = … " is a (let-)binding
<def`>
it is not closed because the ; on line 5 makes ocaml think the following let is a nested expression of this binding
Nahra has quit [Remote host closed the connection]
<Superpelican_>
ok thanks
<Superpelican_>
I’ll try compiling now
Nahra has joined #ocaml
avsm has quit [Ping timeout: 260 seconds]
<Superpelican_>
def`: is the shutdown procedure even possible?
<Superpelican_>
I forgot that OCaml maybe copies the variables/arguments
<Superpelican_>
if I add win as an argument
slash^ has joined #ocaml
<Superpelican_>
def`: and win is destroyed with Sdl.destroy_window won’t the copy just be destroyed then?
<def`>
ocaml copies nothing
<Superpelican_>
ok
<def`>
and you are right that the win value is not bound in the scope of shutdown
<Superpelican_>
I added win as an argument
<Superpelican_>
Now I’m getting: “Error: This pattern matches values of type [? `Ok ] but a pattern was expected which matches values of type Tsdl.Sdl.surface Tsdl.Sdl.result Types for tag `Ok are incompatible”
<Superpelican_>
on line 19
<def`>
Hehe, any idea why you get this error?
<Superpelican_>
Well yes
<ggole>
oriba: hmm, maybe something is catching it :/
<Superpelican_>
I think it is caused by the last match body in the file
<def`>
where does img come from
<oriba>
ggole, Maybe I can explore it in more detail later... need to go. thx so far
oriba has quit [Quit: oriba]
<ggole>
The ocamlnet docs mention a catch-all handler that is on by default, that could be it
<acieroid>
Sdl.Rect.create seems to be what you're looking for
avsm has joined #ocaml
maattdd has joined #ocaml
<Superpelican_>
acieroid: thanks :)
avsm1 has quit [Ping timeout: 245 seconds]
hhugo has joined #ocaml
maattdd has quit [Ping timeout: 272 seconds]
pminten has joined #ocaml
samrat has quit [Ping timeout: 264 seconds]
Denommus has quit [Changing host]
Denommus has joined #ocaml
avsm has quit [Quit: Leaving.]
<Superpelican_>
def`: ok, I was able to fix the call to blit_surface thanks to acieroid’s link :)
<Superpelican_>
def`: I’m now getting “Error: This expression has type Tsdl.Sdl.surface Tsdl.Sdl.result but an expression was expected of type Tsdl.Sdl.surface” on line 23
<Superpelican_>
So looks like I still haven’t really fixed the last match body
avsm has joined #ocaml
samrat has joined #ocaml
<acieroid>
Superpelican_: look at the definition of Tsdl.Sdl.result
<acieroid>
and you'll find how to get your Tsdl.Sdl.surface from that
testcocoon has quit [Quit: Coyote finally caught me]
<Superpelican_>
acieroid: so I should place “of” between `Ok and img and `Error and err?
<Superpelican_>
Isn’t “of” only for types?
<Superpelican_>
I don’t know what I would change otherwise
<acieroid>
Superpelican_: no, a value of the result type is either `Error s where s describes the error, or `Ok x where x is the actual return value of the function
<Superpelican_>
wait but the result and variable of type ‘a are reversed
<Superpelican_>
acieroid: But don’t I already have it that way?
arj has quit [Quit: Leaving.]
<acieroid>
you have t he 'a result, you want the 'a
<acieroid>
which *might* be inside the 'a result, but that's not sure (as an error could have happened)
mcclurmc has quit [Remote host closed the connection]
WraithM has quit [Ping timeout: 260 seconds]
koderok has joined #ocaml
claudiuc has quit [Remote host closed the connection]
jao has joined #ocaml
jao has quit [Changing host]
jao has joined #ocaml
claudiuc has joined #ocaml
yacks has joined #ocaml
rand000 has quit [Quit: leaving]
avsm has joined #ocaml
philtor has quit [Ping timeout: 260 seconds]
koderok has quit [Quit: koderok]
artagnon has joined #ocaml
<artagnon>
To malloc, I have to declare_function the malloc and build_call it, right?
jwatzman|work has quit [Quit: jwatzman|work]
<artagnon>
There's no shortcut wrapper like build_malloc?
<adrien>
artagnon: wrong channel?
<adrien>
or there's something I really don't understand
<mrvn>
ocaml has no malloc :)
<artagnon>
OCaml LLVM bindings actually.
<adrien>
ah
<mrvn>
what are they actually? BIndings to drive the compiler from ocaml so you can compile stuff or a frontend so you can compile ocaml with llvm?
<artagnon>
The former.
<artagnon>
You can write an LLVM-based compiler in OCaml without emitting IR by hand.
<Superpelican_>
def`: I’m now getting “Error: syntax error” on line 30, I now have the following code: http://pastie.org/9462628
artagnon has left #ocaml [#ocaml]
Kakadu has quit [Ping timeout: 246 seconds]
<def`>
Superpelican_: are you sure ? this code seems correct
<Superpelican_>
yep
<Superpelican_>
def`: Maybe the actual error is located on another line?
<Superpelican_>
Or have you already read the whole file? :D
<def`>
I read and passed it through ocamlc
<Superpelican_>
def`: So you mean it compiles?
dsheets has quit [Ping timeout: 260 seconds]
<Superpelican_>
?
<Superpelican_>
now it compiles!
<def`>
:P
<Superpelican_>
I didn’t change anything
<Superpelican_>
maybe I forgot to save or something like that
<Superpelican_>
OMG
<Superpelican_>
I have actually compiled my first, real OCaml program :)
<def`>
congratulations :D
<Superpelican_>
not just someone else’s example
philtor has joined #ocaml
<Superpelican_>
but my own little demo
<Superpelican_>
let’s try it :D
<Superpelican_>
it works!
<Superpelican_>
no errors
<Superpelican_>
that was pretty smooth
<Superpelican_>
and getting all the dynamic library stuff working was a breeze too thanks to OPAM :)
<Superpelican_>
I have always been puzzled how to compile a C++ program with a dynamic library
<Superpelican_>
or it’s just OS X
* Superpelican_
just switched from Linux a month ago
<bjorkintosh>
nah.
<bjorkintosh>
it's just you.
<bjorkintosh>
kidding. i have no idea.
samrat has quit [Ping timeout: 240 seconds]
<Superpelican_>
Even though my application only displays a picture that I borrowed (read: stole) from NASA, it still feels like a (small) accomplishment
WraithM has joined #ocaml
<bjorkintosh>
it is.
<bjorkintosh>
you should be proud.
bezirg has joined #ocaml
thomasga has joined #ocaml
Thooms_ has joined #ocaml
samrat has joined #ocaml
<jeroud>
Superpelican_: Nice.
rgrinberg has quit [Quit: Leaving.]
troutwine is now known as troutwine_away
* jeroud
isn't sure how much work is left in his first real OCaml project.
yomimono has joined #ocaml
maattdd has quit [Ping timeout: 240 seconds]
troutwine_away is now known as troutwine
avsm has quit [Quit: Leaving.]
ygrek_ has joined #ocaml
ygrek has quit [Ping timeout: 272 seconds]
thomasga has quit [Quit: Leaving.]
ygrek has joined #ocaml
ygrek_ has quit [Ping timeout: 250 seconds]
divyanshu has joined #ocaml
divyanshu has quit [Client Quit]
malo has joined #ocaml
hhugo has quit [Quit: Leaving.]
jao has quit [Ping timeout: 240 seconds]
oriba has joined #ocaml
pyon has quit [Quit: Fiat justitia ruat caelum.]
Kakadu has joined #ocaml
freling has joined #ocaml
mcclurmc has joined #ocaml
samrat has quit [Quit: Computer has gone to sleep.]
WraithM has quit [Ping timeout: 250 seconds]
mcclurmc has quit [Remote host closed the connection]
tac_ has joined #ocaml
fold has quit [Ping timeout: 240 seconds]
philtor_ has quit [Ping timeout: 264 seconds]
<Superpelican_>
def`: BTW are you an experienced OCaml programmer?
<Superpelican_>
def`: I’m wondering if you think my code was OCaml’ish, or alien ;)
agarwal1975 has quit [Quit: agarwal1975]
<Drup>
hard to answer considering that 1) it's small 2) the library is a very thin binding to C, so not idiomatic to begin with.
<def`>
Superpelican_: moderately experienced. your code was correct for a beginner, but…
<Superpelican_>
it isn’t very OCaml’ish?
<def`>
1) try to stay close to the guidelines concerning indentation, eventually use tools like ocp-indent to do so
<Drup>
Superpelican_: also, ocaml indentation is usually 2 spaces :p
<Superpelican_>
so no tabs
<Superpelican_>
:(
<Superpelican_>
I too at first used 2 spaces
<Superpelican_>
but everyone used tabs in the Python world
<Superpelican_>
and now I should use 2 spaces again ;)
<def`>
2) it was OCaml'ish in the sense that you made use of ocaml features :) (you didn't really had choice as you were guided by the library :))
<Superpelican_>
ok, that’s good
<Superpelican_>
I’m trying to make use of the basic OCaml features
<def`>
3) but you pinpointed the main problem : repetitive. ocaml provides basic features, but those are highly composable which means you'll have to build your own abstracions
<Superpelican_>
although I haven’t really completely read Real World OCaml yet
<Superpelican_>
so I don’t know about some advanced features yet
<Superpelican_>
and I still find polymorphic variants confusing
<def`>
Also, Drup is right, the sdl binding is really low-level, so it doesn't help writing idiomatic code.
<def`>
It's the minimum layer above C-code.
<Superpelican_>
yeah that was to be expected
<Superpelican_>
of a thin binding
<Superpelican_>
which almost directly maps to C code ;)
<def`>
Yes. You can skip polymorphic variants etc by following RWO, you will use those when appropriate.
<Superpelican_>
ok, that’s reassuring :)
<whitequark>
def`: "moderately experienced"
mcclurmc has joined #ocaml
mcclurmc has quit [Remote host closed the connection]
rgrinberg has joined #ocaml
mcclurmc has joined #ocaml
<Drup>
(I wonder in which other community a guy hacking the typechecker like you do would be described as "moderately experienced")
<def`>
:P all is relative
<Superpelican_>
:)
mcclurmc has quit [Remote host closed the connection]
ygrek has quit [Ping timeout: 244 seconds]
manizzle has joined #ocaml
<smondet>
Drup: well, a guy hacking python's typechecker is a "total beginner" :)
ygrek has joined #ocaml
<Drup>
ahah x)
<Drup>
I expected this kind of remark :D
fold has joined #ocaml
Superpelican_ has quit [Quit: Superpelican_]
dsheets has joined #ocaml
yomimono has quit [Read error: Connection reset by peer]
mcclurmc has joined #ocaml
yomimono has joined #ocaml
yomimono has quit [Read error: Connection reset by peer]
yomimono has joined #ocaml
yomimono has quit [Read error: Connection reset by peer]
Thooms has quit [Quit: Towards infinity and beyooooooond]
yomimono has joined #ocaml
yomimono has quit [Read error: Connection reset by peer]
yomimono has joined #ocaml
yomimono has quit [Read error: Connection reset by peer]
yomimono has joined #ocaml
yomimono has quit [Read error: Connection reset by peer]
yomimono has joined #ocaml
yomimono has quit [Read error: Connection reset by peer]
yomimono has joined #ocaml
yomimono has quit [Read error: Connection reset by peer]
yomimono has joined #ocaml
yomimono has quit [Read error: Connection reset by peer]
yomimono has joined #ocaml
yomimono has quit [Read error: Connection reset by peer]
yomimono has joined #ocaml
ggole has quit []
yomimono has quit [Read error: Connection reset by peer]
oriba_ has joined #ocaml
oriba has quit [Ping timeout: 240 seconds]
_andre has quit [Quit: leaving]
avsm has joined #ocaml
jwatzman|work has joined #ocaml
eikke__ has joined #ocaml
kakadu_ has joined #ocaml
Kakadu has quit [Quit: Konversation terminated!]
freling has quit [Ping timeout: 260 seconds]
bezirg has quit [Ping timeout: 272 seconds]
freling has joined #ocaml
ygrek has quit [Ping timeout: 245 seconds]
Algebr has quit [Ping timeout: 244 seconds]
BitPuffin has quit [Ping timeout: 272 seconds]
BitPuffin has joined #ocaml
<Anarchos>
Is there an ocaml implementation of the Martelli-Montanari algorithm for unification ?
* whitequark
has read that as Martelli-Monogatari
tac_ has left #ocaml ["Leaving"]
<Anarchos>
whitequark i will do one then :)
<Anarchos>
whitequark and make it a functor of a term module
<whitequark>
oh, the unification thing
<whitequark>
good idea!
<Anarchos>
whitequark i printed the article at work ;)
<Anarchos>
whitequark and to add more fun to it i will program it in literate programming style.
jao has joined #ocaml
jao has quit [Changing host]
jao has joined #ocaml
dsheets has quit [Ping timeout: 250 seconds]
bezirg has joined #ocaml
eikke__ has quit [Ping timeout: 240 seconds]
eikke__ has joined #ocaml
<Drup>
whitequark: how would you go at iterating on all the edges of the CFG of an llvm function ?
<Drup>
iterate at all the successor for each basicblock ?
<mrvn>
.oO(recursively)
hbar has joined #ocaml
<mrvn>
DID WE FLY TO THE MOON TOO SOON?
<whitequark>
Drup: yes
<whitequark>
no other way
<Drup>
that's what I though, good
<Drup>
whitequark: If I consider a terminator, is there a simple way to retrieve the lluses associated with the edges to the next basic blocks ?
<whitequark>
I don't think so
<Drup>
:(
<whitequark>
what API would you propose? we can get it merged
<mrvn>
you know, compilers are verry good at checking syntax.
<dcampbell_>
I would like to structure my code so that I have a module A with a submodule B, and corresponding files a/b.ml, a/b.mli b/mod.ml b/mod.mli (or similar name) where everything in mod.mli can be referenced outside the module as a.thing_in_a, is there an easy/standard way to do this sort of thing?
<dcampbell_>
a/mod.ml and a/mod.mli I mean
<mrvn>
dcampbell_: in a.mli include the mod.mli
kakadu_ has quit [Quit: Konversation terminated!]
thomasga1 has joined #ocaml
<Drup>
dcampbell_: you want that your directory structure is reflected at the module level ? If so, that's not how it works in ocaml
<xvilka>
hm, strange, i have ~/.ocamlinit with proper requires still have a bitching about unbound module 'Core'
Arsenik has quit [Remote host closed the connection]
<mrvn>
dcampbell_: I've been thinking of having a/b.ml provide an module type Internal and External and then in a/b.mli include the Internal type and in a then the External type. The idea would be to keep all the interface and code in a single file.
<Drup>
xvilka: there are obvious mistakes, but I will let your decipher the error messages, for educational purposes :D
<whitequark>
and you could definitley use ppx_import with ppx_deriving like
<whitequark>
type t = [%import: Foo.t] [@@deriving Enum]
<whitequark>
mrvn: the problem with C enums is that they don't have a defined ABI
<whitequark>
so you can't FFI to them without generating C code anyway
<mrvn>
whitequark: they are totaly defined
joncfoo has joined #ocaml
<Drup>
we discussed that already.
<mrvn>
implementation defined in the calling conventions
<mrvn>
and usualy enums are ints or you can specify a different type easily enough
<whitequark>
they're not ints with real compilers.
<whitequark>
mrvn: well, if you want an importer from C enums, I can make that for you as a PoC
<whitequark>
easy enough
WraithM has joined #ocaml
<mrvn>
close enough to int that you can ignore the differences
<mrvn>
enough C sources do
<whitequark>
close enough, except it segfaults
<mrvn>
whitequark: what segfaults?
<Drup>
whitequark: be a man, like mrvn, and use Obj.magic to fix segfaults.
<whitequark>
do I *have* to construct an example which would segfault due to enum size being different, or will you trust my word?
<whitequark>
e.g. put it into a structure
<whitequark>
after a char
<mrvn>
whitequark: in a struct it will be int, unsigned int or larger integer type as needed.
<mrvn>
when it is larger then specify it.
<mrvn>
doesn't have to work 100% automatic.
<whitequark>
what makes you think it will be an int?
<mrvn>
I'm more concerned with getting the mapping between C value and ocaml value.
<mrvn>
whitequark: that is what the C specs say
<whitequark>
where?
<whitequark>
I did check them, of course
<bitbckt>
6.7.2.2.
<mrvn>
whitequark: wherever it discusses the storage size and alignment requirements for enums.
<bitbckt>
Each enumerated type shall be compatible with char, a signed integer type, or an unsigned integer type. The choice of type is implementation-defined, but shall be capable of representing the values of all the members of the enumeration.
<mrvn>
bitbckt: exactly, implementation defined.
<whitequark>
≠ is an int.
<mrvn>
enum Foo { BLA }; sizeof(Foo) == 4
<mrvn>
on all the archs I know.
<bitbckt>
it doesn't have to be; that could easily be a char.
<mrvn>
bitbckt: it could. It isn't.
<whitequark>
mrvn: ... even if that is actually true for all interesting compilers in existence
<whitequark>
which I don't believe in
<whitequark>
then it's still not entire story
<mrvn>
whitequark: 16bit DSPs will have shorts or even char.
<whitequark>
no, that's too obscure
<Drup>
It reminds me of a very clever comment I read once in some C sources
<whitequark>
OCaml doesn't run there anyway
<Drup>
"No compiler should be clever enough to optimize that"
<Drup>
whitequark: well, mrvn comment does remind me that
<mrvn>
Sometimes, like with that, you would have to specify the type since the default assumption of int wouldn't work.
<Drup>
"don't worry, it's ok for all the compiler i know !"
<mrvn>
Drup: the compiler can't optimize that. The ABI specifies that a simple enum uses a signed int.
englishm has quit [Remote host closed the connection]
<mrvn>
Drup: it's defined in the calling conventions the compiler adheres to for gcc.
<whitequark>
hm
avsm has quit [Remote host closed the connection]
<whitequark>
mrvn: what about Windows?
englishm has joined #ocaml
<mrvn>
whitequark: don't know, don't care.
<Drup>
that's not exactly what the paragraph quoted by bitbckt says
<whitequark>
Drup: I agree that "ABI docs specify that on every platform OCaml runs on" is sufficient
enquora has joined #ocaml
<mrvn>
Drup: what bitbckt says it is implementation defined. That definition is in the ABI in the case of gcc.
<mrvn>
s/says/says that/
<whitequark>
but I completely disagree with Windows being "don't care"
<mrvn>
whitequark: I don't care. you can care. others certainly will.
<mrvn>
whitequark: it's likely windows uses int as minimum size too since that is the fastest integer type.
<mrvn>
or short because it comes from 16bit.
<bitbckt>
fwiw, Windows should always be an int by virtue of being ANSI C, not C99 (from which I quoted)
<bitbckt>
in ANSI-land, enums are always ints.
<whitequark>
bitbckt: thanks
<whitequark>
mrvn: okay, so I agree: your solution is generic enough
<bitbckt>
np
<whitequark>
in practice for OCaml at least
<whitequark>
s,generic,general,
<mrvn>
whitequark: anyway. You need the option of specifying a type anyway, for when int is insufficient. The ppx code could deduce that from the values but that might be harder to do.
<mrvn>
and differ for every arch/abi
bezirg has quit [Ping timeout: 244 seconds]
<Drup>
since we are on the subject
<whitequark>
it'll have to have some ABI knowledge anyway
<whitequark>
could as well encode the rules
<whitequark>
they're not *That* complex
<Drup>
whitequark: for my enum issue, do you have a minimal example I can extend/play with ?
<mrvn>
does ctypes work with ppx?
<whitequark>
no
<whitequark>
and shouldn't
<whitequark>
ctypes doesn't parse C headers.
<mrvn>
I would want enums parsed through ppx specifically for ctypes
<whitequark>
well, sure? it makes sense to use ctypes
<whitequark>
Drup: what's your enum issue?
<Drup>
bind it, while the rest of my binding is ctypes-powered
<mrvn>
Drup: my use case exactly too
<whitequark>
Drup: yes, as I've said: substitute it for int unless it has values over 2**32
<whitequark>
this should get you going for every platform OCaml is currently available on
<mrvn>
whitequark: 2**31 on 32bit.
<Drup>
hum, no C needed then ?
<whitequark>
right
<whitequark>
Drup: I looked at your llvm code and it is ok
<mrvn>
actually 2**30, int32 for 2**31, uint32 for 2*32, (u)int64 beyond that
<whitequark>
I meant for the C type
<whitequark>
but yes, that's true as well
<mrvn>
this could get ugly on the ocaml side
<mrvn>
did ctypes have something that uses int32/int64 on 32bit archs and plain int on 64bit archs?
<whitequark>
nativeint?
<whitequark>
and a view
<mrvn>
nativeint is nativeint
<whitequark>
how would you use different ocaml-side types on different archs?
<mrvn>
whitequark: that was the question
<whitequark>
why would you want to do that?
<whitequark>
you're screwing over all your downstream users, if you have any
<whitequark>
including other your modules
englishm has quit [Remote host closed the connection]
englishm has joined #ocaml
<mrvn>
int is way faster. One of my projects has an Int63 module that uses int64 on 32bit and plain int on 64bit. Uses different sources depending on the arch.
<mrvn>
only for binary though, bytecode is always int64.
<whitequark>
well.
<whitequark>
you could cleverly use ppx_import and ppx_clang for that
<whitequark>
(ppx_clang being the hypothetical extension that extracts definitions from headers)
hhugo has joined #ocaml
joncfoo has left #ocaml ["Leaving"]
joncfoo has joined #ocaml
<joncfoo>
Is there an easy way to create string representations of custom types? So far I've figured out that I have to use sexplib (http://hastebin.com/icilaromup.hs)
<Drup>
sexplib, as you said, or deriving. In the next version of ocaml, ppx_deriving
<mrvn>
Drup: 4.0.2?
<joncfoo>
thanks
<Drup>
yes
englishm has quit [Remote host closed the connection]
<whitequark>
mrvn: 4.02
hhugo has quit [Quit: Leaving.]
<Drup>
ah, yeah, obviously
shinnya has joined #ocaml
mcclurmc has quit [Remote host closed the connection]
mcclurmc has joined #ocaml
darkf has joined #ocaml
<Drup>
ok, I'm quite happy with my experimentation x)
<Drup>
for example, the dominator functor need add_edge
<Drup>
(don't ask me why, I didn't look at the code, I find it extremely weird)
<whitequark>
I bet it tries to break critical edges itself, or something like that
<Drup>
probably, but I feel like you could split the functor in a read-only part
<Drup>
I'm gonna add pre-applied functors before releasing it
tov has joined #ocaml
maufred has quit [Ping timeout: 255 seconds]
eikke__ has quit [Ping timeout: 240 seconds]
ebzzry has joined #ocaml
maattdd has joined #ocaml
maufred has joined #ocaml
<Drup>
hum, the path functor are going to be suboptimal with this interface
<Drup>
they compute the weigh from the label, which is always unit :(
madroach has quit [Ping timeout: 250 seconds]
<whitequark>
huh, what would you normally assign?
<Drup>
on the label ?
<whitequark>
eys
<whitequark>
yes
<Drup>
for now, it's always unit, there is no label
madroach has joined #ocaml
<Drup>
I would like to add the use, but as I told you before, it's annoying to get the use when looking at the successors
<Drup>
I don't see any way to do that, except by getting the successor, getting it's uses and finding the right one by iteration on them
Thooms_ has quit [Ping timeout: 260 seconds]
<Drup>
and it's horrible, I don't want to do that
<whitequark>
simply mark the edge with (from llblock, to llblock) tuple
<Drup>
that's what I do currently, but setting this couple for the label is going to make the function E.create very akward
mcclurmc has joined #ocaml
<Drup>
does the C++ interface contain a mapping from user to uses that is not in the C/Ocaml api ?
<whitequark>
hrm
<whitequark>
yes. getOperandUSe
<Drup>
ah!
<whitequark>
you can add that to the C & OCaml APIs & I'll merge.
<whitequark>
it seems like a thing that could be reviewed post-commit
thomasga1 has quit [Quit: Leaving.]
* Drup
takes a deep breath at the idea of writing C code.
mcclurmc has quit [Ping timeout: 244 seconds]
<whitequark>
C++ code, even.
<Drup>
:O
<whitequark>
muahahaha
<Drup>
I'm lost and terrified without my typechecker :(
<whitequark>
it's a trivial change though
mcclurmc has joined #ocaml
araujo has quit [Read error: Connection reset by peer]
araujo has joined #ocaml
BitPuffin has quit [Ping timeout: 240 seconds]
maufred has quit [Ping timeout: 255 seconds]
<Drup>
whitequark: some read-only algorithm use marking (http://ocamlgraph.lri.fr/doc/Sig.IM.Mark.html) for a more efficient version, do I think I should add a marked interface (basically, a graph would a couple llfun, int Hashtable) or I don't care ?
englishm has quit [Remote host closed the connection]
maufred has joined #ocaml
yomimono has quit [Ping timeout: 250 seconds]
<Drup>
(I'm busily applying functor, then I will try to open some C++ file)
englishm has joined #ocaml
<Drup>
-"I think" =')
rgrinberg has quit [Quit: Leaving.]
S11001001 has quit [Quit: ERC Version 5.3 (IRC client for Emacs)]