barkmadley[m] has left #ocaml ["Kicked by @appservice-irc:matrix.org"]
FreeBirdLjj has quit [Remote host closed the connection]
dhil has joined #ocaml
AlexDenisov has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
AlexDenisov has joined #ocaml
bobbypriambodo has quit [Quit: ERC (IRC client for Emacs 25.1.1)]
bobbypriambodo has joined #ocaml
rossberg has quit [Ping timeout: 264 seconds]
bobbypriambodo has quit [Ping timeout: 240 seconds]
frefity has quit [Ping timeout: 240 seconds]
mengu has joined #ocaml
rossberg has joined #ocaml
moei has joined #ocaml
frefity has joined #ocaml
_andre has joined #ocaml
dx has quit [Quit: RIP]
AlexDenisov has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
dx has joined #ocaml
zpe has joined #ocaml
mengu has quit [Remote host closed the connection]
silver has joined #ocaml
dch_ has quit [Read error: Connection reset by peer]
frefity has quit [Ping timeout: 255 seconds]
frefity has joined #ocaml
AlexDenisov has joined #ocaml
snhmib has joined #ocaml
dhil has quit [Ping timeout: 260 seconds]
rpg has joined #ocaml
malc_ has joined #ocaml
rpg has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
Onemorenickname has joined #ocaml
<Onemorenickname>
hello again
<Onemorenickname>
last time i asked my question, it was 2 am and i got to leave
<Onemorenickname>
<Onemorenickname> if i have a function making lists, and i can prove that those lists are non-empty
<Onemorenickname>
<Onemorenickname> is there some place where I can see the proofs I can make this way ?
<Onemorenickname>
<Onemorenickname> then i can make a function to the type ('a * 'b) array
<Onemorenickname>
<Onemorenickname> if i have a function making two arrays, and I can prove that those arrays have the same size
<Onemorenickname>
<Onemorenickname> then i can make a function to the type ('a * 'a list)
<Onemorenickname>
sorry for the duplicate ._.
bobbypriambodo has joined #ocaml
dhil has joined #ocaml
<Drup>
that's quite generic ...
<companion_cube>
you can write a section "proofs" in the .mli file, I guess?
<companion_cube>
type 'a t = private 'a array … val same_len : 'a t -> 'b t -> ('a * 'b) t`
<chindy>
Onemorenickname: just fyi i am not sure if this is intetional or not but at one point you have ('a * 'a list) and on the other ('a *'a) list ... the one is a list of pairs and the other is a pair containing an element and a list
<chindy>
or rather array
<Onemorenickname>
chindy, i know
<Onemorenickname>
it is intentional
<Onemorenickname>
Drup, i know, hence looking for more detailed things
<Onemorenickname>
companion_cube, oh, i meant, is there some place where I can find other "proofs"
<Onemorenickname>
to see what kind of properties I can express in ocaml
<Drup>
but that could be anything, your description captures any proof done about any program
<companion_cube>
the type system is not really tailored for that
<Drup>
Your properties are precisely not the one captured by the OCaml type system, by the way
<chindy>
I honestly dont understand exactly what you/he wants, but isn't he just asking for an existence proof of a function, by which a pure "example" of a function of that type would suffice?
<Drup>
chindy: except both examples don't fit that
<Onemorenickname>
Drup, Drup, how so ? if I can make a function returning a ('a * 'a list), then it's equivalent to a function returning a non-empty list
<Drup>
Onemorenickname: yes but you can't prove that inside the OCaml type system
<Onemorenickname>
(I used a module "Ne_list" because at some point in my code I needed non-empty lists, with the same functions as in List)
<Onemorenickname>
ofc I can, if my function returning a ('a * 'a list) is well typed, then I have proved that it returns a ('a * 'a list), aka, a non-empty list
<Onemorenickname>
well, the Ocaml type system proved that for me
<Drup>
I mean, you can't prove the bijection at the type level. You can't formally express "the subset of things of type 'a list that are not []"
<Drup>
You can only provide an encoding, by transforming them into 'a * 'a list
<Onemorenickname>
a non-empty list can only be made through "Con", I just had to replace all calls to "Con" (I don't how "Con" is called in ocaml, "(::)" maybe) to "make x y = (x,y)"
<Onemorenickname>
Drup, of course it is an encoding
<chindy>
Ocaml has no dependant types so you cannot really proof that your list is empty ... unless you create a new type that has no empty list, which si weird
<Onemorenickname>
I am wondering where I can find more encodings
<Drup>
"opam list -a" ? :D
<Drup>
I mean, most ocaml libraries do that, one way or another ...
<Onemorenickname>
"that" ?
<Drup>
encoding properties in the type systems to constraint the space of acceptable values
<Onemorenickname>
so far, the only properties I can encode are regarding size : list of size greater or equal to k, array/list/hashmap of the same size etc.
<Drup>
does mean you can prove them inside the type system (the proof is auxiliary, sometimes trivial)
<Drup>
doesn't*
<Drup>
This is very different from actually proving things, like what you would do in Agda/Idris/Coq
<Onemorenickname>
how so ?
<Onemorenickname>
the program is not a proof wrt the type checker ?
bobbypriambodo has quit [Quit: ERC (IRC client for Emacs 25.1.1)]
<Onemorenickname>
for instance, if a function returning 'a list only use "::" to make the returned lists and never "[]", then I can automatically transform it to a function returning 'a Ne_list, aka, a proof of non-emptyness
<Drup>
How do you express "{ l in 'a list, nonempty(l) } = ('a * a list)" in the type system exactly ?
<octachron>
Onemorenickname, does "let rec f = function | [] -> f [] | a :: q -> a, q " prove that all function are not empty?
<octachron>
s/function/lists
<Onemorenickname>
Drup, with a module, and making ('a * 'a list) and 'a list functionally equivalents
<Onemorenickname>
octachron, it proves that when it terminates, the result is a non-empty list
<Onemorenickname>
yep
<companion_cube>
termination is not enforced though
<Onemorenickname>
companion_cube, well, when it does not terminate, we don't really care : there is no value
<Drup>
nontermination in a logical setting make things inconsistent, you can't really prove anything if you accept non terminating and/or exceptions in your proofs.
<Onemorenickname>
does "let rec f x = f x" prove that no value of any type exist ? as it will never terminate
<Onemorenickname>
Drup, if you restrain yourself to the non-terminating cases, how does that make things inconsistent ?
<Drup>
Onemorenickname: I think you have a really really fuzzy definition of what proofs are
<Onemorenickname>
Drup, when the compiler tells me "f" has type "a -> b", it has proved that if I give f an a, and that f terminates on that a, I will get a b
<Onemorenickname>
it does not give me that proof, but it has proved it
<Armael>
one thing relevant in that context may be the parametricity "free theorems"?
<Drup>
Armael: yeah, it's the "done properly" version of what he's saying
<octachron>
Onemorenickname, the halting problem means that you cannot discard that easily non-terminating program
<Onemorenickname>
octachron, how the halting problem is relevant here ? the ocaml type system does just that
<Onemorenickname>
again, when the compiler tells me "f" has type "a -> b", it has proved that if I give f an a, and that f terminates on that a, I will get a b
<Onemorenickname>
Armael, I will look into that
<Drup>
Onemorenickname: except the ocaml type system is not a consistent logical as soon as you introduce bottom :D
<Armael>
so I guess you can go read "Theorems for free!" by Philip Wadler
<Onemorenickname>
Armael, google linked me to stackoverflow which linked me to that paper
<Onemorenickname>
haha :D
<Drup>
(and let rec f x = f x is pretty much bottom)
<Onemorenickname>
Drup : do you have any inconsitency of the ocaml type system produced by bottom ?
bobbypriambodo has joined #ocaml
<Onemorenickname>
I never read anything telling me that the ocaml type system is broken because there can be non-terminating computations
<Drup>
I never said it was broken
<Drup>
I said it was not a logic.
<Armael>
its (on purpose) logically inconsistent
<Drup>
the curry-howard isomorphism is not voodoo magic that you can wave around to make things formal. You need a sound logic and a programming language associated to it for it work. As soon as you introduce programming language features such as non termination, mutability and exceptions that are not captured by the type system, it doesn't work anymore
<companion_cube>
Onemorenickname: if you want to prove OCaml programs in a serious way, you should use either why3 or CFML
<Onemorenickname>
Drup, inconsistency means I can have a representant of any type
<Onemorenickname>
it does not mean that the proof that my function is well-typed is wrong
<companion_cube>
Onemorenickname: but in OCaml you can do stuff like `unit -> 'a`
<companion_cube>
let () = assert false
<Onemorenickname>
ofc
<Onemorenickname>
what I mean is that I don't see how it's relevant to what I am saying
<Drup>
Onemorenickname: It means that you don't have a direct connection between a type and a logic proposition
<companion_cube>
if you have a value of type a->b, it might be a valid proof of "a implies b" in some sound system, but OCaml type-checking it is not sufficient evidence
<Onemorenickname>
ok
<Onemorenickname>
companion_cube, i agree, but that was not what i was talking about
<Drup>
That's .. pretty much what you said, though
<Onemorenickname>
what i said is that if you have a function f : t -> x list
<Onemorenickname>
and that you can transform it to a function of type t -> (x * x list)
<Onemorenickname>
then you have a proof that the first one only gave non-empty lists
<companion_cube>
a function such as `let f _ = assert false`?
<Onemorenickname>
companion_cube, a -> b means when you give it an a and it terminates, it gives you a b
<Onemorenickname>
i dont think "assert false" terminates
<companion_cube>
you mean terminate without exceptions? :p
<Armael>
in full generality, you need to solve the halting problem to know that statically
<Onemorenickname>
Armael, of course, but I didnt ask for full generality, I asked for other examples
<companion_cube>
Onemorenickname: the issue really is that your function might terminate, but it might not, hence it is no interesting proof
<Drup>
Onemorenickname: define "transform"
<octachron>
Onemorenickname, if you only have a function of type "t -> x list", you cannot generally transform it to a function of type "t -> (x*x list)"
<Onemorenickname>
companion_cube, if you have a separate proof for that function termination, then it is interesting (most of the function I code do terminate)
<Onemorenickname>
octachron, of course
<companion_cube>
meh
<companion_cube>
proving termination of OCaml isn't trivial :/
<companion_cube>
but I'm wondering what you are really trying to achieve
<Onemorenickname>
companion_cube, in general, it is not
<companion_cube>
if you want formal proofs of your programs, raw OCaml is not the best option
<freehck>
companion_cube: isn't provini termination of any program impossible? :)
<companion_cube>
types are ok for coarse grained invariants and runtime safety
<freehck>
*proving
<companion_cube>
freehck: no
<companion_cube>
it's only proving the termination of all programs that is impossible
<Onemorenickname>
Drup, let's say I have f : a -> b, and I transform it to g : a -> c, then I have a function h such that h (g a) = f a
<companion_cube>
i.e. you cannot write an algorithm that proves termination of its inputs
<companion_cube>
but for a given program, you might prove it terminating
<freehck>
companion_cube: k, got you.
<Onemorenickname>
companion_cube, i don't want formal proofs of the whole program, just to see what kind of small properties I can use in ocaml
<Onemorenickname>
for instance, I use my module "Ne_list" for when I need to know a list is non-empty
<companion_cube>
right
ziyourenxiang has joined #ocaml
<Onemorenickname>
and I now use many times ('a * 'b) list/array instead of pairs of list/array when I want to know they have the same size
<companion_cube>
the way I would do it: `module Ne_list: sig type 'a t = private 'a list val make : 'a list -> 'a t option … end`
<Onemorenickname>
"option"
<companion_cube>
using ('a * 'b) array is fine
<companion_cube>
yes, option
<Drup>
Onemorenickname: what you just said doesn't hold in the presence of mutability
<companion_cube>
you need to construct the list somehow
<Onemorenickname>
I want to know statically that the list is non-empty
<Onemorenickname>
not test it dynamically
<Onemorenickname>
Drup, what do you mean ?
<companion_cube>
or it could be : `val empty : 'a val append : 'a t -> 'a list -> 'a t`
<companion_cube>
this kind of things
<companion_cube>
depending on how you build the lists
<Drup>
Onemorenickname: well, first, you still need to define "transform"
<Onemorenickname>
companion_cube, oh, indeed, i had to replicate the "List" module functions
<flux>
onemorenickname, I think the way to go is to have: type 'a non_empty_list = 'a * 'a list and then express your code in terms of non_empty_list
<Onemorenickname>
Drup, if I have a function f of type a -> b, transforming it to a function g of type a -> c means I have a function h of type c -> b such that forall x, f x == h (g x)
<flux>
it's going to be annoying ;)
Twister_ has quit [Quit: Page closed]
<Onemorenickname>
flux, that's what i've done
<Onemorenickname>
and as i duplicated the lists function in Ne_list
<Onemorenickname>
it works without being annoying
<companion_cube>
it's annoying to write Ne_list though
<Onemorenickname>
what i'm seeking is for other properties I can express with that kind of module
<Drup>
Onemorenickname: what I'm trying to say is that, if you want to get theorems from the type system, you need to constrain yourself to a specific subset of OCaml (which is going to be pretty much system F). It's nowhere near "all of OCaml"
<Drup>
Onemorenickname: DEFINE TRANSFORM è_é
<Drup>
grmbl.
<companion_cube>
:DD
<Onemorenickname>
Drup, how is the thing I just told you not a definition ?
<companion_cube>
provide (a -> b) -> c -> d, I guess
<Onemorenickname>
You can replace syntactically "transform f to g" by "providing a function h satisfying those conditions"
<Onemorenickname>
companion_cube, is there not some kind of ad-hoc module polymorphism or whatever allowing me not to write "Ne_list" ? (so far, I haven't managed to use it, so I do write "Ne_list" and "List", but I write these the same way I write "List", "Array" and so on)
freehck has quit [Quit: "restart"]
<companion_cube>
if 'a Ne_list.t = 'a * 'a list, certainly not, you have to write new code
<octachron>
Onemorenickname, trying to rephrase what you are saying: if f: E → F is an one-to-one mapping then f(E) is a subset of F
frefity has quit [Ping timeout: 255 seconds]
<companion_cube>
with what I wrote you can almost `include List` for the implementation
<companion_cube>
(assuming it's correct to do so, heh(
<Onemorenickname>
companion_cube, ooooh, I see what you mean
<Onemorenickname>
indeed I wrote new code
<companion_cube>
have you looked at my snippet?
<Onemorenickname>
that's what I meant by "duplicating the lists function in Ne_List"
<companion_cube>
it would almost work with a .ml file that states `module NE_list = List`
<Onemorenickname>
no, I4ve forgotten, there were so many messages D:
<companion_cube>
(well you'd have to write append_right = append, but anyway)
<Onemorenickname>
companion_cube, oh, this is another way to do it
<Onemorenickname>
I can have a function head and tail with your types
snhmib has quit [Ping timeout: 260 seconds]
freehck has joined #ocaml
nomicflux has joined #ocaml
<Onemorenickname>
and I only have to make dirty code in the module, never outside
<Onemorenickname>
so it works too
<Onemorenickname>
(by dirty code, I mean "let head x = function | [] -> failwith "impossible" | hd::tl -> hd"
<Onemorenickname>
)
snhmib has joined #ocaml
<Onemorenickname>
for small modules, this is a fine way to do it I guess
<Onemorenickname>
but if the module grows bigger, then I get the same problem as when using simple lists : I have to keep track of the invariants myself
eimpec has joined #ocaml
AlexDenisov has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
<companion_cube>
Onemorenickname: but be careful that `tail: 'a t -> 'a list`
<Onemorenickname>
ofc
<companion_cube>
well of course you are responsible for enforcing the invariants yourself`
AlexDenisov has joined #ocaml
<companion_cube>
:D
frefity has joined #ocaml
<Onemorenickname>
well, with "type t = 'a * 'a list;;", I don't have to enforce anything myself :D
<Onemorenickname>
but the code I write is longer, I admit
<Onemorenickname>
(get it, I "admit")
<flux>
a coverity-like static code analyzer for ocaml would be pretty interesting.
<flux>
if you feel like you don't have enough to do.. ;-)
<Onemorenickname>
haha
<companion_cube>
or just use why3
<companion_cube>
;-) ;-)
<Onemorenickname>
i'd like ocaml macros
<Onemorenickname>
looking into "why3
<Onemorenickname>
"
sh0t has joined #ocaml
zpe has quit [Remote host closed the connection]
shinnya has joined #ocaml
vicfred has quit [Ping timeout: 255 seconds]
freusque has quit [Quit: WeeChat 1.6]
freusque has joined #ocaml
<Drup>
So
<flux>
octachron, codept, cool!
vicfred has joined #ocaml
snhmib has quit [Ping timeout: 240 seconds]
<Drup>
Onemorenickname: just to make an example of the terrible things you can do in OCaml, here is a counter example to the first paragraph of "theorem for free" https://bpaste.net/show/edb3d2f3d30e
<companion_cube>
eeek
snhmib has joined #ocaml
vicfred has quit [Quit: Leaving]
<Drup>
You can still do it if you remove pointer equality *and* poly equality, with existential types and references for example
<Drup>
or with first class modules
<Drup>
of with open sum types
<Drup>
(parametricity and free theorems are great, but you can apply none of this stuff directly to OCaml, except if you restrain the language a lot)
<Drup>
(for your "non empty lists": as soon as I have any information about the type of things inside the list, I can cheat with pointer equality or things like hmap)
MercurialAlchemi has quit [Ping timeout: 240 seconds]
<Drup>
A recent paper called "Contextual Isomorphisms" show a bit what you really need to do to talk about isomorphic types when mutability is involved
<Drup>
(in particular, there is a nice isomorphism where unit ≡ bool if your language has at least one integer reference :D)
<companion_cube>
type unit = true | false | file_not_found
<Drup>
companion_cube: don't be picky, admire the fuckyness of the example
<companion_cube>
you're trying to have `f o g = g o f = id`?
cbot has joined #ocaml
<Drup>
yes
<companion_cube>
cause g o g doesn't seem to behave nicely :3
<Drup>
(it's not mine, it's in Levy's paper
<Drup>
go read it
<companion_cube>
no thanks
<Drup>
Onemorenickname: Reynolds' abstraction theorem is another very nice thing (it says that if you use M : S, and you get another module N : S, you can replace M by N and it behaves the same). It still doesn't apply to OCaml unfortunatly :/
copy` has joined #ocaml
<reynir>
My (crappy) irc bot broke somehow
<reynir>
I guess that means I *have* to port it to calculon now :-)
dhil has quit [Ping timeout: 255 seconds]
<companion_cube>
:DDD
<companion_cube>
good luck
<companion_cube>
(there's a sample bot in the repo though)
dhil has joined #ocaml
jabroney has joined #ocaml
noddy has quit [Ping timeout: 240 seconds]
ryanartecona has joined #ocaml
govg has joined #ocaml
cbot has quit [Quit: This computer has gone to sleep]
ryanartecona has quit [Quit: ryanartecona]
ryanartecona has joined #ocaml
govg has quit [Ping timeout: 240 seconds]
snhmib has quit [Ping timeout: 268 seconds]
snhmib has joined #ocaml
ziyourenxiang has quit [Quit: Leaving]
Onemorenickname_ has joined #ocaml
snhmib has quit [Ping timeout: 240 seconds]
dch_ has joined #ocaml
Onemorenickname has quit [Ping timeout: 255 seconds]
MercurialAlchemi has joined #ocaml
nomicflux has quit [Quit: nomicflux]
snhmib has joined #ocaml
frefity has quit [Ping timeout: 260 seconds]
AlexDenisov has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
<Onemorenickname_>
Drup : It's a shame I have to work right now
<Onemorenickname_>
But thanks for the references !
dch_ has quit [Remote host closed the connection]
AlexDenisov has joined #ocaml
bobbypriambodo has quit [Quit: ERC (IRC client for Emacs 25.1.1)]
frefity has joined #ocaml
malina has joined #ocaml
snhmib has quit [Ping timeout: 255 seconds]
sz0 has joined #ocaml
snhmib has joined #ocaml
rcsole has quit [Ping timeout: 268 seconds]
rcsole has joined #ocaml
shinnya has quit [Ping timeout: 240 seconds]
shinnya has joined #ocaml
nomicflux has joined #ocaml
yomimono has joined #ocaml
larhat has quit [Quit: Leaving.]
snhmib has quit [Ping timeout: 260 seconds]
jnavila has quit [Ping timeout: 240 seconds]
ousado_ has joined #ocaml
Onemorenickname_ has quit [Read error: No route to host]
snhmib has joined #ocaml
Onemorenickname_ has joined #ocaml
fds_ has joined #ocaml
fds has quit [Ping timeout: 240 seconds]
lyxia has quit [Ping timeout: 240 seconds]
hannes has quit [Ping timeout: 240 seconds]
djellemah has quit [Ping timeout: 240 seconds]
ousado has quit [Ping timeout: 240 seconds]
hannes` has joined #ocaml
djellemah has joined #ocaml
lyxia has joined #ocaml
rcsole has quit [Ping timeout: 260 seconds]
govg has joined #ocaml
AlexDenisov has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
rpg has joined #ocaml
rpg has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
dch_ has joined #ocaml
rpg has joined #ocaml
<octachron>
flux, thanks!
nomicflux has quit [Quit: nomicflux]
eimpec has quit [Ping timeout: 260 seconds]
hannes` is now known as hannes
dhil has quit [Ping timeout: 240 seconds]
Flerex has joined #ocaml
rpg has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
d0nn1e has quit [Ping timeout: 255 seconds]
d0nn1e has joined #ocaml
snhmib has quit [Ping timeout: 260 seconds]
yomimono has quit [Ping timeout: 260 seconds]
dhil has joined #ocaml
jnavila has joined #ocaml
Onemorenickname has joined #ocaml
Onemorenickname_ has quit [Ping timeout: 260 seconds]
<flux>
TIL mxe.cc. seems like it could be used for cross-compiling ocaml programs to Windows as well.
<flux>
amazing how that project is already 9 years old and I never (remember having) heard of it.
<adrien>
well
<adrien>
if it's still single-minded about static linking, you've got a practical issue :)
<flux>
I think there was some shared library compilation options being mentioned. but hey, linking exception ;).
<flux>
or were you referring to some practical issue not relateed to licensing?
<flux>
says "Packages: static shared" on the github front page"
<adrien>
yeah, maybe they've improved
<flux>
nevertheles in general I really don't see it as a downside
<flux>
if you're going to deliver a single windows app, seems like static linking is a boon..
<adrien>
but if you only care about ocaml libs, you actually don't have real problems ahead
<flux>
it is the windows way, no?-)
<adrien>
but I bet you'll use some C libs too
<adrien>
flux: good luck packing your resources that way :)
<flux>
hmm, my first app I compile with MXE is probably going to be based on C++/Qt/Qml so I guess that's a theoretical problem right there ;)
snhmib has joined #ocaml
Onemorenickname has quit [Ping timeout: 255 seconds]
<adrien>
so
<adrien>
150MB?
rbocquet has quit [Ping timeout: 240 seconds]
rbocquet has joined #ocaml
noddy has joined #ocaml
Mercuria1Alchemi has joined #ocaml
Onemorenickname has joined #ocaml
jnavila has quit [Ping timeout: 240 seconds]
MercurialAlchemi has quit [Ping timeout: 260 seconds]
noddy has quit [Ping timeout: 260 seconds]
<flux>
still installing.. probably will be intsalling for some time as it hasn't even downloaded the packages yet, decided to just have a go at full install ;)
ryanartecona has quit [Quit: ryanartecona]
jao has joined #ocaml
Simn has quit [Ping timeout: 240 seconds]
snhmib has quit [Ping timeout: 240 seconds]
ygrek has joined #ocaml
jnavila has joined #ocaml
dch_ has quit [Quit: ZZ]
Onemorenickname has quit [Ping timeout: 255 seconds]
AlexDenisov has joined #ocaml
sz0 has quit [Quit: Connection closed for inactivity]
<SomeDamnBody>
Is there a way to calculate the union between a Set and a Hash_set in ocaml?
<SomeDamnBody>
Or between two Hash_set instances?
<SomeDamnBody>
in ocaml => Using core_kernel
atsampson has quit [Ping timeout: 240 seconds]
<flux>
well, you can fold over the Set and add its elements to Hash_set or vice versa?
atsampson has joined #ocaml
Onemorenickname has joined #ocaml
<SomeDamnBody>
Yeah, I was just looking for something like a union function as Set has, but that would accept a hash_set. I'm thinking there is some way to use interfaces regarding the functions mem or contains or something you know
<flux>
well, I haven't used Core but I doubt it exists.
<SomeDamnBody>
Ah ok.
noddy has joined #ocaml
larhat has joined #ocaml
Simn has joined #ocaml
cdidd has quit [Ping timeout: 260 seconds]
zpe has joined #ocaml
<companion_cube>
funny, I have CCHashSet.S.union :-]
<Drup>
companion_cube: it's between hashsets, no ?
<companion_cube>
yes yes
cbot has joined #ocaml
malc_ has quit [Quit: ERC (IRC client for Emacs 25.0.50.2)]
Onemorenickname has quit [Ping timeout: 255 seconds]
cdidd has joined #ocaml
Onemorenickname has joined #ocaml
Onemorenickname has quit [Read error: Connection reset by peer]