jonludlam has quit [Remote host closed the connection]
RMacy has joined #ocaml
tlockney is now known as tlockney_away
lostcuaz has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
travisbrady has joined #ocaml
gereedy has quit [Ping timeout: 240 seconds]
rand000 has quit [Quit: leaving]
gereedy has joined #ocaml
zpe_ has joined #ocaml
zpe has quit [Ping timeout: 240 seconds]
RMacy has quit []
nikki93_ has quit [Remote host closed the connection]
RMacy has joined #ocaml
RMacy has quit [Client Quit]
madroach has quit [Ping timeout: 252 seconds]
xianxu has quit [Ping timeout: 264 seconds]
madroach has joined #ocaml
jwatzman|work has quit [Quit: jwatzman|work]
pyon has joined #ocaml
gustav has quit [Ping timeout: 264 seconds]
ousado has quit [Read error: Connection reset by peer]
avsm has joined #ocaml
gereedy has quit [Ping timeout: 240 seconds]
cdruzac has quit [Ping timeout: 240 seconds]
maufred has quit [Ping timeout: 240 seconds]
pango has quit [Ping timeout: 240 seconds]
pango has joined #ocaml
maufred has joined #ocaml
gereedy has joined #ocaml
_habnabit has quit [Ping timeout: 240 seconds]
S11001001 has quit [Ping timeout: 240 seconds]
_habnabit has joined #ocaml
S11001001 has joined #ocaml
avsm has quit [Ping timeout: 255 seconds]
S11001001 has quit [Changing host]
S11001001 has joined #ocaml
__marius__ has quit [Ping timeout: 240 seconds]
Simn has quit [Quit: Leaving]
__marius__ has joined #ocaml
gereedy has quit [Ping timeout: 240 seconds]
bitbckt has quit [Ping timeout: 240 seconds]
S11001001 has quit [Quit: ERC Version 5.3 (IRC client for Emacs)]
dlat has quit [Ping timeout: 240 seconds]
adrien_oww has quit [Ping timeout: 240 seconds]
adrien_oww has joined #ocaml
_habnabit has quit [Ping timeout: 240 seconds]
stomp has quit [Ping timeout: 240 seconds]
bitbckt has joined #ocaml
_habnabit has joined #ocaml
gereedy has joined #ocaml
stomp has joined #ocaml
dlat has joined #ocaml
ousado has joined #ocaml
_cdruzac has joined #ocaml
travisbrady has quit [Quit: travisbrady]
nikki93 has joined #ocaml
_habnabit has quit [Ping timeout: 240 seconds]
gereedy has quit [Ping timeout: 240 seconds]
_habnabit has joined #ocaml
_habnabit has quit [Changing host]
_habnabit has joined #ocaml
gereedy has joined #ocaml
bitbckt has quit [Ping timeout: 240 seconds]
_habnabit has quit [Ping timeout: 240 seconds]
bitbckt has joined #ocaml
gereedy has quit [Ping timeout: 240 seconds]
Guest97126 has joined #ocaml
maufred has quit [Ping timeout: 240 seconds]
maufred has joined #ocaml
gereedy has joined #ocaml
q66 has quit [Ping timeout: 255 seconds]
_habnabit has joined #ocaml
gereedy has quit [Ping timeout: 240 seconds]
_habnabit has quit [Remote host closed the connection]
maufred has quit [Ping timeout: 240 seconds]
_habnabit has joined #ocaml
_habnabit has quit [Changing host]
_habnabit has joined #ocaml
arjunguha has joined #ocaml
gereedy has joined #ocaml
gereedy has quit [Ping timeout: 240 seconds]
_habnabit has quit [Ping timeout: 240 seconds]
arjunguha has quit [Ping timeout: 240 seconds]
Don_Pellegrino has joined #ocaml
gereedy has joined #ocaml
bitbckt has quit [Ping timeout: 240 seconds]
bitbckt has joined #ocaml
arjunguha has joined #ocaml
maufred has joined #ocaml
boogie has quit [Remote host closed the connection]
habnabit has joined #ocaml
habnabit is now known as _habnabit
S11001001 has joined #ocaml
S11001001 has quit [Changing host]
S11001001 has joined #ocaml
ygrek has joined #ocaml
tlockney_away is now known as tlockney
gustav has joined #ocaml
jave has quit [Ping timeout: 264 seconds]
jave has joined #ocaml
tulloch has quit [Ping timeout: 255 seconds]
talzeus_ has quit [Read error: Connection reset by peer]
gereedy has quit [Ping timeout: 240 seconds]
segmond has joined #ocaml
gustav has quit [Ping timeout: 240 seconds]
gustav has joined #ocaml
phay has joined #ocaml
maufred has quit [Ping timeout: 240 seconds]
maufred has joined #ocaml
gereedy has joined #ocaml
introom has joined #ocaml
arjunguha has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
arjunguha has joined #ocaml
arjunguha has quit [Client Quit]
gustav has quit [Ping timeout: 255 seconds]
gustav has joined #ocaml
arjunguha has joined #ocaml
boogie has joined #ocaml
yacks has joined #ocaml
boogie has quit [Remote host closed the connection]
talzeus has joined #ocaml
Don_Pellegrino has quit [Quit: Konversation terminated!]
watermind has quit [Quit: Konversation terminated!]
samwise__ has joined #ocaml
<samwise__>
Hello , I have a query regarding streams. It is a question in textbook of sorts.
<samwise__>
THe book states that one way to implement streams is a function over non-negative integers.Given a stream s : int -> int the first element is (s 0 ) , second .. (s 1 ) and so on, how does one exactly implement such a thing?
avsm has joined #ocaml
yacks has quit [Ping timeout: 240 seconds]
arjunguha has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
<Drup>
I'm always a bit bothered by those indexed streams, because I don't understand what's the point
avsm has quit [Ping timeout: 240 seconds]
<samwise__>
Drup : Indexed streams ... how have I not heard about these things as a haskell newbie ...
<samwise__>
:part
samwise__ has quit [Quit: Page closed]
<Drup>
hum, I'm not sure I answered the question x)
nikki93 has quit [Remote host closed the connection]
watermind has joined #ocaml
nikki93 has joined #ocaml
WraithM_ has quit [Quit: leaving]
nikki93 has quit [Ping timeout: 240 seconds]
boogie has joined #ocaml
tlockney is now known as tlockney_away
Enjolras has quit [Ping timeout: 264 seconds]
WraithM has joined #ocaml
travisbrady has joined #ocaml
RMacy has joined #ocaml
yacks has joined #ocaml
nikki93 has joined #ocaml
introom has quit [Ping timeout: 240 seconds]
nikki93 has quit [Read error: Connection reset by peer]
nikki93 has joined #ocaml
S11001001 has quit [Quit: ERC Version 5.3 (IRC client for Emacs)]
xianxu has joined #ocaml
divyanshu has joined #ocaml
divyanshu has quit [Client Quit]
RMacy has quit []
nikki93 has quit [Remote host closed the connection]
nikki93 has joined #ocaml
boogie has quit [Remote host closed the connection]
boogie has joined #ocaml
nikki93 has quit [Ping timeout: 255 seconds]
paolooo has joined #ocaml
<seliopou>
how do you create a string literal that contains a null character?
<seliopou>
"\\0" doesn't do the trick
<seliopou>
or rather "\0"
divyanshu has joined #ocaml
divyanshu has quit [Client Quit]
<seliopou>
ah, it's "\x00"
<seliopou>
or "\000"
divyanshu has joined #ocaml
siddharthv_away is now known as siddharthv
divyanshu has quit [Client Quit]
introom has joined #ocaml
claudiuc has joined #ocaml
claudiuc_ has quit [Ping timeout: 264 seconds]
travisbrady has quit [Quit: travisbrady]
watermind has quit [Ping timeout: 255 seconds]
paolooo has quit [Quit: Page closed]
boogie has quit [Remote host closed the connection]
divyanshu has joined #ocaml
divyanshu has quit [Client Quit]
divyanshu has joined #ocaml
divyanshu has quit [Client Quit]
limitless23 has joined #ocaml
limitless23 has left #ocaml []
divyanshu has joined #ocaml
divyanshu has quit [Quit: Computer has gone to sleep.]
divyanshu has joined #ocaml
divyanshu has quit [Client Quit]
divyanshu has joined #ocaml
ygrek has quit [Ping timeout: 255 seconds]
introom has quit [Ping timeout: 255 seconds]
divyanshu has quit [Quit: Computer has gone to sleep.]
hto_ has quit [Ping timeout: 240 seconds]
hto has joined #ocaml
Guest97126 has quit [Ping timeout: 264 seconds]
adrien__ is now known as adrien_
yacks has quit [Ping timeout: 240 seconds]
boogie has joined #ocaml
axiles has joined #ocaml
divyanshu has joined #ocaml
divyanshu has quit [Client Quit]
boogie has quit [Ping timeout: 255 seconds]
divyanshu has joined #ocaml
xianxu has quit [Ping timeout: 240 seconds]
divyanshu has quit [Client Quit]
divyanshu has joined #ocaml
nikki93 has joined #ocaml
ygrek has joined #ocaml
yacks has joined #ocaml
tov has quit [Quit: Reconnecting]
tov has joined #ocaml
tov has quit [Remote host closed the connection]
angerman has joined #ocaml
nikki93 has quit [Remote host closed the connection]
nikki93 has joined #ocaml
nikki93 has quit [Ping timeout: 255 seconds]
yacks has quit [Ping timeout: 264 seconds]
nikki93 has joined #ocaml
sgnb` has quit [Read error: Connection reset by peer]
sgnb` has joined #ocaml
boogie has joined #ocaml
xianxu has joined #ocaml
boogie has quit [Ping timeout: 240 seconds]
xianxu has quit [Ping timeout: 264 seconds]
arjunguha has joined #ocaml
adrien_ is now known as adrien
Arsenik has joined #ocaml
arjunguha has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
PM has quit [Ping timeout: 245 seconds]
maattdd has joined #ocaml
Kakadu has joined #ocaml
cago has joined #ocaml
ikaros has joined #ocaml
tulloch has joined #ocaml
AltGr has joined #ocaml
xianxu has joined #ocaml
xianxu has quit [Ping timeout: 240 seconds]
Simn has joined #ocaml
sgnb` has quit [Read error: Connection reset by peer]
sgnb has joined #ocaml
Enjolras has joined #ocaml
PM has joined #ocaml
mika1 has joined #ocaml
Thooms has joined #ocaml
ggole has joined #ocaml
ikaros has quit [Quit: Ex-Chat]
cago has quit [Quit: Leaving.]
cago has joined #ocaml
boogie has joined #ocaml
jonludlam has joined #ocaml
avsm has joined #ocaml
tulloch has quit [Ping timeout: 255 seconds]
xianxu has joined #ocaml
boogie has quit [Ping timeout: 253 seconds]
xianxu has quit [Ping timeout: 240 seconds]
introom has joined #ocaml
zpe_ has quit [Remote host closed the connection]
zpe has joined #ocaml
elfring has joined #ocaml
elfring has quit [Client Quit]
zpe has quit [Read error: Operation timed out]
<gasche>
companion_cube: I sent you a solution to the (convenient ('a ty)) question we discussed yesterday
<elfring>
I would prefer to analyse a directory by a loop.
ousado has quit [Ping timeout: 264 seconds]
<gasche>
elfring: you're making a mistake that shows you misunderstand how the language work in a fairly important way
<gasche>
I think that it would be a good time to focus on understanding the code you wrote (what it actually means, rather than what you want it to mean) and why it's wrong
<gasche>
finding a way that is correct will not necessarily prevent you from doing that mistake again
<gasche>
good programmers have a correct mental model of how their programming language works
<gasche>
companion_cube: the record builder work because the ('builder) type gets one argument added by each Field constructor
<elfring>
I know a bit about a few design choices between loops and recursion.
<gasche>
the order of parameters in Field is counter-intuitive, you would expect the 'next' bit to be last; I initially started this way and hit a wall when trying to write a library function to produce a record from its description
<gasche>
the slightly-backward way it is now is the best thing I've found that works (for now)
<gasche>
hm
<companion_cube>
gasche: ok, the ordering matters
<gasche>
also obviously the order between my_record and "let fields" is wrong, let me fix that
<companion_cube>
that's quite nice actually
<companion_cube>
wait
<elfring>
I am not going ot use the module "Hashtbl" because I do not want to fiddle with key collisions for my source code example.
<gasche>
elfring: why does
<gasche>
let repeat x n = let li = [] in for i = 1 to n do (x :: li) done; li
<gasche>
always return the empty list?
<gasche>
instead of (x :: x :: x :: ... :: []) as expected
<companion_cube>
gasche: last remark, maybe you can avoid CPS if the builder is the outermost construcor (then you apply the function to each field one by one), atlhough I'm not sure it would type
<elfring>
Is a map class available where the function calls "mem" and "add" are combined in a single operation? How do you think about to pass a function for a corresponding key handling?
tulloch has quit [Ping timeout: 240 seconds]
tulloch has joined #ocaml
<Drup>
elfring: I don't think so, but write your own :)
<Drup>
it's a little one liner :p
tulloch has quit [Client Quit]
boogie has joined #ocaml
<gasche>
companion_cube: nice idea, needs to be tried
nikki93 has quit [Ping timeout: 240 seconds]
<gasche>
you wouldn't be tail-recursive but that's fine as records have small number of fields
cago has joined #ocaml
<ggole>
Core's map has such an operation iirc
<whitequark>
Drup: but what if you want it to be atomic?
boogie has quit [Ping timeout: 240 seconds]
ollehar1 has joined #ocaml
<elfring>
Was it tried before to avoid unnecessary key lookups for the function call combination "mem" and "add" for maps?
<Drup>
atomicity is a delicate concept to take about when you are reasoning on immutable data structures.
<Drup>
talk*
<Drup>
elfring: yes, use one of the extended library, like Core or Batteries
<Drup>
whitequark: atomicity only makes sense on mutable operations
<Drup>
you can't have race conditions with immutable structures.
yacks has quit [Quit: Leaving]
<ggole>
I don't think the motivation was to avoid lookups
<ggole>
Because Map is persistent, I think you have to do two traversals anyway.
<companion_cube>
gasche: about sums, I think you need to write two functions
cago1 has joined #ocaml
cago has quit [Ping timeout: 252 seconds]
<Drup>
(It's called "modify" in batteries)
<Drup>
ggole: only if you modify the key
<ggole>
Right: if you want "insert this if it is not there, otherwise nothing" you only need one traversal in the already there case.
<ggole>
So arguably there should be both operations.
<Drup>
anyway
<Drup>
it's very very premature optimisation
<Drup>
and if this start counting, you probably need something else than Map already.
mort___ has quit [Quit: Leaving.]
<ggole>
Mmm
<ggole>
Balanced binary trees aren't really wonderful
<flux>
well they aren't all -very- balanced, are they? mostly balanced maybe.
yacks has joined #ocaml
<ggole>
The unbalancedness(?) is bounded, though
<gasche>
"mem and add together" is easy to do on paper, with zippers
<gasche>
but zippers have bothersome constant costs, so in practice people optimize with an ugly interface
<flux>
I remember once wondering why my trees aren't balanced. after a small refresher I realized, yes, a branch can be half the height of another..
<Drup>
gasche: as I understood it, he just want "let foo map x f = add map (f (mem map x))
<Drup>
no need to zip around for that.
<companion_cube>
gasche: looks better
<nicoo>
Drup: Atomicity is a *trivial* concept when dealing with immutable structures :>
<companion_cube>
but the real challenge is sums
<Drup>
nicoo: trivial hence not interesting
<Drup>
nicoo: my point :p
<ggole>
Don't you still have to fence when publishing immutable structures?
<companion_cube>
depends on the GC
<nicoo>
Drup: I answered after reading the “delicate” line
<ggole>
(In the context of "genuine" multiprocessing, that is.)
<flux>
it doesn't solve the problem of n threads wanting to add data to a tree concurrently though
<flux>
well I suppose it might, if you have a efficient tree merge algorithm
<ggole>
Merge raises some difficulties
<flux>
and probably few problems are bounded by the speed to update the tree
<ggole>
What do you do with duplicate entries? The semantics of single threaded code is that the latest one wins.
<nicoo>
ggole: No (assuming you don't have a ridiculously broken memory model)
<nicoo>
flux: Concurrent update just doesn't make sense for immutable structures
<Drup>
"update" doesn't make sens already
<Drup>
adding the "concurrent" keyword doesn't help
maattdd has quit [Ping timeout: 240 seconds]
divyansr__ has quit [Quit: Connection closed for inactivity]
<nicoo>
Drup: Well, if you have a sequential process, doing let foo = Foo.something bar foo in [...] can be thought of as “update” as long as you admit that update isn't mutation.
<ggole>
nicoo: I'm not sure that's right. x86 allows loads to be reordered with respect to (older) stores to different locations.
<ggole>
I think that means that you can see a stale value by accessing through a published pointer.
<ggole>
And there are weaker systems than x86, of course.
<nicoo>
ggole: Your threads have no synchronisation guarantees. What would you enforce with a memory barrier on a single pointer write ?
<ggole>
The visibility of the data pointed to by the published pointer?
darkf has quit [Quit: Leaving]
<Enjolras>
There is an easy enough solution : do not use shared data structure.
<nicoo>
Ah. Yes indeed. I was implicitely assuming that my new cells aren't aliasing with out-of-date cache on another process, but I'm not sure the GC enforces this.
<nicoo>
Enjolras: read-sharing isn't a huge issue (and is often necessary)
<Enjolras>
nicoo: i don't see where you have an issue with read sharing of immutable structure, as long as the GC fences after doing a move
<ggole>
Right. On the other hand memory barriers are notoriously easy to get wrong, so perhaps I'm being overly conservative and fencing is unnecessary (or is only necessary on strange hardware like the Alpha).
<nicoo>
Enjolras: Read my second-to-last message
michael_lee has joined #ocaml
<nicoo>
ggole: They are. Let's use atomics everywhere ! (or not)
<ggole>
Unfortunately fences are pretty expensive.
<nicoo>
By the way, there is a rather interesting debate in the distributed systems community, regarding whether there is interesting stuff strictly weaker than atomic R/W, and how can you account for barriers in complexity.
* nicoo
stabs Drup with a swordfish.
<Drup>
fencs*
<nicoo>
fences*
Kakadu has quit [Ping timeout: 245 seconds]
<gasche>
companion_cube: I don't think sums are more difficult than records
<companion_cube>
gasche: I think you have to repeat the variant names twice
<gasche>
Drup: I meant the zipper avoids traversing the tree structure twice
<companion_cube>
that's doable, of course
boogie has joined #ocaml
maattdd has joined #ocaml
nikki93 has joined #ocaml
<Drup>
gasche: but even, since it's the same element for mem and add, you don't need a real zipper, just a direct search and replace
<Drup>
you could say it's still a zipper, sure
<Drup>
but it's overkill
ollehar1 has quit [Ping timeout: 240 seconds]
<gasche>
Drup: zipper allow to factorize mem+add+find+replace etc., coding the traversal only once
<gasche>
otherwise yes
avsm has joined #ocaml
watermind has joined #ocaml
watermind has quit [Client Quit]
shinnya has joined #ocaml
Kakadu has joined #ocaml
cago1 has quit [Quit: Leaving.]
cago has joined #ocaml
ollehar has quit [Read error: Operation timed out]
<adrien_oww>
gasche: would 'a ty be considered a "stable" interface?
<adrien_oww>
i.e. is there at least some possibility that it could be a standard and that the only remaining issue would be how to generate the data?
<adrien_oww>
which would make camlp4-based implementations possible (which would in turn enhance portability)
<companion_cube>
I think it would benefit from being packaged independently so that it can be used in many libraries
<Drup>
pretty please, avoid camlp4 and wait for extension-point
divyanshu has quit [Quit: Computer has gone to sleep.]
<adrien_oww>
well, the point is to not care now about how you generate them
<adrien_oww>
it it takes camlp4 to add support in 4.00 and 4.01 then...
<adrien_oww>
and that camlp4 can provide support for 4.02 and 'a ty only gets merged in 4.03, then I believe it makes sense
<companion_cube>
"it" means the module Ty
<gasche>
companion_cube: this is magic
<gasche>
I just did sums
<gasche>
and I'm not even sure how they work :-'
<companion_cube>
please show! :D
<companion_cube>
(btw it may actually be quite fast to use 'a ty, because conversion to Json/Sexp/etc. is direct)
<companion_cube>
(no clue yet about de-serialization which is harder)
<gasche>
adrien_oww: I'm currently trying to explore the option of doing it in pure OCaml
Fullma has joined #ocaml
<gasche>
with no syntax extensions involved
<companion_cube>
looks interesting
<gasche>
the main difficulty being that the API then needs to be nice for humans
<companion_cube>
don't worry, we'll cook a higher level API :>
<gasche>
while sexplib/etc. are fine with arbitrary level or inderection or magic
<Drup>
gasche: automatic deriving is not possible ?
<companion_cube>
it should be
<companion_cube>
but it shouldn't be mandatory
<gasche>
my design goal today is to not need it
<companion_cube>
gasche: I like the part that describes how to build a sum
<companion_cube>
without the functions I had to write
<companion_cube>
very good, I believe we can actually do this
<gasche>
syntactic metaprocessing is a different option (which allows you to write simpler code, as you life the type-correctness requirement)
<gasche>
and type-directed inference (as in ocaml-ty) is another
<companion_cube>
(care to create a "ty" repository, to evolve into a small lib?)
<gasche>
today, we're looking at "everything by hand"
<companion_cube>
if it's easy to write for humans, it's easy to generate for people who prefer so
<gasche>
yes but if you know you'll generate upfront you have other design options for efficiency or whatever
<gasche>
also
<gasche>
I'm not quite sure how this solution would scale to handling GADTs
<companion_cube>
I meant you should design for humans, it's the most flexible
<gasche>
whereas ocaml-ty can
<companion_cube>
you mean, describing GADTs themselves?
<gasche>
yes
<companion_cube>
tough
<companion_cube>
although... what would go wrong?
<gasche>
I'm not sure how to express the refinement of typing environment that happens when matching on a GADT
<companion_cube>
oh I know, types may appear when (fun pa pb -> function A a -> pa a | B b -> pb b)
<companion_cube>
some existential would escape
<gasche>
that would probably require polymorphic "case" functions, while they're currently monomorphic
<gasche>
yes
<companion_cube>
I think it's reasonable not to be able to serialize GADTs for now
<companion_cube>
(printing is more problematic...)
<def-lkb>
gasche: does "polymorphic case function" has a formal meaning?
jonludlam has joined #ocaml
avsm1 has quit [Quit: Leaving.]
<gasche>
a classic variant constructor | Foo of bar
<gasche>
has a "case function", in a pattern whose global return type is baz, of type (bar -> baz)
<def-lkb>
yes I get this part, but what polymorphic means in this context?
<gasche>
a GADT constructor with an existential type | Foo : 'ex -> t
<gasche>
has a "case function" of type (forall 'ex. 'ex -> t)
<def-lkb>
ohhh, I see. Thanks
<companion_cube>
you would need to wrap the function in a record...
<ggole>
Hmm, when I tried to represent types with a GADT I ended up having something like | Record: record -> record t and losing all correspondence of structure
<companion_cube>
nah, it's more complicated
avsm has joined #ocaml
<ggole>
I'm not sure I follow what's going on with the 'builder stuff there, though
<ggole>
Does it encode fields as arguments of a function type?
boogie has quit [Remote host closed the connection]
<gasche>
from the outside, 'builder is the type of the record-creating function (that take one parameter per field)
<gasche>
inside it is incrementally constructed, each Field constructor adding its parameter to the long currified function
<gasche>
hm
<companion_cube>
ah, I see, with my old solution GADTs would work
<ggole>
Hmm, OK
<companion_cube>
(because the target type would be given by the function)
<gasche>
note companion_cube that the current presentation with builders outside makes the expert-library code cleaner, but the GADT definition (and building its elements) slightly more confusing
<companion_cube>
(function |SomeGADT x -> ty_x, x)
<ggole>
If you needed arbitrary tuples you'd need a similar trick, I suppose
<gasche>
companion_cube: yeah, we can abuse partiality this way
<companion_cube>
gasche: I don't think the user should understand every detail of the GADTs
<companion_cube>
only type signatures of the combinators matter
<companion_cube>
"this is how you describe a record field"
<gasche>
not the type signature, the code examples
<companion_cube>
that too
<companion_cube>
both are important
<gasche>
the type signature is exactly similar to the type of the GADTs constructors
<companion_cube>
but yeah, most of the time you just follow the examples
<companion_cube>
(also, you need a fixpoint variant, but well)
<companion_cube>
it becomes more subtle afterwards, with fixpoint, maps, etc.
<gasche>
inded
<gasche>
+e
<companion_cube>
this evening, if it's ok with you, I'll probably make a repo to explore this (and extend it with everything necessary)
yacks has quit [Ping timeout: 240 seconds]
yacks has joined #ocaml
avsm has quit [Ping timeout: 253 seconds]
<gasche>
fine with me
avsm has joined #ocaml
nikki93 has joined #ocaml
<companion_cube>
ok, good
<companion_cube>
(means that batteries would maybe depend on the library... we'll see later)
divyanshu has joined #ocaml
nikki93 has quit [Remote host closed the connection]
nikki93 has joined #ocaml
Thooms has quit [Ping timeout: 240 seconds]
<gasche>
I feel the signal/noise ratio on reddit/haskell is going down
<gasche>
maybe I'm just less patient
<gasche>
r/ocaml, on the contrary, could use some more noise
<adrien_oww>
reddit algorithm's has changed recently too
<Drup>
if you compare to r/ocaml ... :D
<def-lkb>
that's a global tendency on the web, psnr is going down
cago1 has joined #ocaml
cago has quit [Quit: Leaving.]
<gasche>
def-lkb: yeah, things were less noisy before the web was invented :-'
<gasche>
you'd get technical newsletters in your mailbox *in real life*
<gasche>
what a peace it probably was
<def-lkb>
:)
<gasche>
like our "holiday week without internet access", except all year long
<gasche>
this thought is borderline terrifying
<smondet>
gasche: companion_cube: dyntype.ml looks really cool. Just one comment if I may, not using the disambiguation for the 2 `Yield` would make it a bit easier to read.
nikki93 has quit [Ping timeout: 240 seconds]
<gasche>
smondet: do you have good naming suggestion?
<gasche>
obviously there is StopSum and StopRecord but...
<smondet>
since it is a linked list, maybe Field_cons Field_nil ?
<smondet>
not sure what's better
avsm1 has joined #ocaml
avsm has quit [Ping timeout: 240 seconds]
siddharthv is now known as siddharthv_away
siddharthv_away has quit [Quit: Lost terminal]
jonludlam has quit [Ping timeout: 240 seconds]
<adrien_oww>
s/Stop/Commit/
<adrien_oww>
?
<adrien_oww>
(haven't followed much, I'm banging my head on the walls because of openembedded)
ygrek has joined #ocaml
wwilly has joined #ocaml
nikki93 has joined #ocaml
<flux>
it's quite interesting how opam can resolve dependencies so that 'opam install pprint' causes 'upgrade merlin.1.5 to 1.6' :)
<flux>
does it do it because, say, it needs to recompile merlin regardless?
<companion_cube>
smondet: I think the final user will use combinators and no the GADT itself (not directly)
<flux>
(I guess re2 was upgraded because it was a dependency of pprint and a new version was available, and core_extended was recompiled for that reason)
wwilly has quit [Ping timeout: 240 seconds]
<rks`_>
flux: did it upgrande ocamlfind?
<rks`_>
-n
jonludlam has joined #ocaml
boogie has joined #ocaml
shinnya has quit [Ping timeout: 240 seconds]
<smondet>
companion_cube: I know, but that kind of piece of code is also a good piece for a GADT tutorial :)
nikki93 has quit [Remote host closed the connection]
nikki93 has joined #ocaml
cago has joined #ocaml
watermind has joined #ocaml
nikki93 has quit [Ping timeout: 240 seconds]
talzeus has joined #ocaml
talzeus has quit [Remote host closed the connection]
talzeus has joined #ocaml
nikki93 has joined #ocaml
nikki93 has quit [Remote host closed the connection]
wwilly has joined #ocaml
avsm1 has quit [Quit: Leaving.]
travisbrady has joined #ocaml
jzelinskie has quit [Ping timeout: 245 seconds]
jzelinskie_ has joined #ocaml
Axord has left #ocaml []
arjunguha has joined #ocaml
maattdd has quit [Ping timeout: 252 seconds]
tlockney_away is now known as tlockney
mika1 has quit [Quit: Leaving.]
<hcarty>
Is it possible to build two libraries defined in a single _oasis when both libraries and packed and each library shares sub-module names?
<hcarty>
Library foo ... Modules Bar Baz.... Library mooo ... Modules Bar Baz ...
<smondet>
hcarty: same modules? or same name in different directory?
<hcarty>
I get cmi mismatch errors
<hcarty>
smondet: Same name, different directory
<hcarty>
So the packed result will have Foo.Lib.(...) and Moo.Lib.(.-.), for example
<hcarty>
s/result/results/
<smondet>
I'm not sure but I think it is an ocamlbuild problem, not Oasis
<hcarty>
Ah, thanks. I'll expand my search then
rand000 has quit [Ping timeout: 240 seconds]
<smondet>
ocamlbuild scans the directory and makes a bunch of assumptions
jwatzman|work has joined #ocaml
<Drup>
hcarty: do you get error on build or on install ?
<hcarty>
Drup: Build
<Drup>
weird
<Drup>
I don't use the pack option, but I've done "same name, different directories" successfully before.
<hcarty>
Drup: Do you have an example you're willing to share?
<Drup>
it's more a question of an example that is currently working and showable :D
<hcarty>
In this case I'd prefer to pack as the module names I'm using are fairly generic.
<hcarty>
Drup: :-)
<Drup>
pack manually
<companion_cube>
o/ hcarty
<Drup>
I don't like the option to pack anyway, I always do my "packing" manually
<Drup>
so I have a nice documentation with the pack
cago has quit [Quit: Leaving.]
cago has joined #ocaml
<hcarty>
companion_cube: Hello!
<hcarty>
Drup: The namespace pollution bothers me when not packing. How much it bothers me depends on the library.
boogie has quit [Remote host closed the connection]
tobiasBora has joined #ocaml
arjunguha has quit [Ping timeout: 240 seconds]
arjunguha has joined #ocaml
tlockney is now known as tlockney_away
cago has quit [Ping timeout: 240 seconds]
mort___ has joined #ocaml
cago has joined #ocaml
tlockney_away is now known as tlockney
cago1 has joined #ocaml
cago has quit [Ping timeout: 240 seconds]
arjunguha has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
<companion_cube>
hcarty: we may switch to a full GADT that represents types, actually!
nlucaroni has quit [Ping timeout: 255 seconds]
boogie has joined #ocaml
cago1 has left #ocaml []
<hcarty>
companion_cube: For what/which project?
<companion_cube>
about the serialization issues, it would be even better to have a 'a ty that describes the type 'a (using a GADT) and can be used to serialize/deserialize/print/compare...
<hcarty>
Ah, of course
<hcarty>
"of course" as in I should have realized that was the context
<companion_cube>
:)
travisbrady has quit [Quit: travisbrady]
Kakadu has quit [Quit: Page closed]
angerman has quit [Quit: Gone]
<hcarty>
Regarding my ocamlbuild trouble - oasis adds both library source paths to all compilation include paths.
<companion_cube>
I think it's better to put sub-libraries in distinct folders, with oasis
<companion_cube>
I had to do that too
<hcarty>
So foo/lib.cmi and moo/lib.cmi are found
<hcarty>
companion_cube: They are both under src/ - do you think that's the problem?
<companion_cube>
I don't know, do you have a _tags file?
<hcarty>
All _oasis generated. No includes specified in the generated file.
<companion_cube>
weird
<companion_cube>
I used distinct folders under src/ because otherwise dependencies on thread,unix,etc. would apply to all files
<hcarty>
Moo depends on Foo. I'm guessing that's what is causing the problem.
Arsenik has quit [Remote host closed the connection]
Thooms has joined #ocaml
Arsenik has joined #ocaml
travisbrady has joined #ocaml
jonludlam has quit [Remote host closed the connection]
ollehar has joined #ocaml
arjunguha has joined #ocaml
nikki93 has joined #ocaml
nlucaroni has joined #ocaml
dsheets has quit [Read error: Operation timed out]
Thooms has quit [Read error: No route to host]
arjunguha has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
Kakadu has joined #ocaml
Thooms has joined #ocaml
Guest97126 has joined #ocaml
<elfring>
How many data copying is still involved during the assignment over a reference after an item was added to an OCaml map data structure?
<Enjolras>
what do you mean ? You store references in your Map ?
introom has quit [Ping timeout: 240 seconds]
lostcuaz has joined #ocaml
<Drup>
hcarty: indeed
<Drup>
hcarty: when I did this sort of stuff, the packages were independent
<elfring>
No. - Does the function "Map.add" return a complete copy of the data where an item was added?
<Drup>
No
<Drup>
what can be shared is shared
<companion_cube>
it copie a logarithmic amount of data
<Enjolras>
elfring: no. Worst case is O(ln N) afaik.
<Enjolras>
(where N is the number of elements in the map)
ulfdoz has joined #ocaml
<elfring>
Are there any chances to reduce this kind of data copying for map elements?
<Enjolras>
Map is an AVL right ?
<Enjolras>
elfring: yes, use hashtbl
arjunguha has joined #ocaml
<companion_cube>
elfring: sounds like premature optimization to me
<companion_cube>
does copying a few tree nodes really slow you down?
<Enjolras>
elfring: be aware that memory allocation is really cheap in ocaml. And you should not wrorry to much until it has prooved to be a bottlneck
<elfring>
I would like to avoid the handling of key collisions because of hashing.
<Enjolras>
Hashtbl handles it for you
arjunguha has quit [Ping timeout: 240 seconds]
<elfring>
Copying a few entries might not matter at the beginning ... But improvements for run time behaviour will become interesting for bigger numbers.
bjorkintosh has joined #ocaml
arjunguha has joined #ocaml
mort___ has quit [Quit: Leaving.]
<def-lkb>
gasche: thx
<elfring>
Will any interface variant become available for data structures like "Map" and "Hashtbl" which provides procedures for "add" operations?
<hcarty>
Drup: When I remove the dependency between libraries the problem goes away. If I can't find a fix/work-around I'll submit a bug report.
<Drup>
elfring: I'm not sure to get what you want
<elfring>
Reduction of data copying efforts from functions like "Map.add"
<adrien>
don't fear allocations
<Drup>
User another data structure ?
<Drup>
Use*
xianxu has joined #ocaml
<Drup>
the (ln N) modifications are mandatory for an immutable AVL
<elfring>
Can the handling of mutable maps become easier eventually?
<Drup>
easier ?
<Drup>
it's not difficult
<Drup>
it's just not in standard library's Map module.
<def-lkb>
And it's not really a good idea to promote mutable datastructure (and the current case illustrate the point :D)
<Drup>
I'm not sure from which programming language your background is, but ocaml std libs is mostly minimal, don't except to find anything in it, there are lot's of other libraries that provide other data structures
<elfring>
An add function call could return a smaller value than a complete map, couldn't it?
<def-lkb>
The map is not copied, it is shared.
<Drup>
elfring: I think you should learn the language before trying to nitpick about runtime costs.
<Drup>
because you don't seem to know how it works (for OCaml at least)
<Drup>
(and now, you're never going to mutate a Map)
<Drup>
no*
<elfring>
Which library alternative would you like to recommend from your software collection?
<Drup>
there are two big general purpose libraries : Core and Batteries
<Drup>
you can pick one
<Drup>
I prefer Batteries, but it's up to personal preferences.
<hcarty>
Batteries here too. It has been around publicly for longer than Core, it is developed in the open and it has a more stable interface.
<hcarty>
Core is larger, likely has more stringent and broader testing and has official backing/development resources applied to it.
<hcarty>
Both are very nice additions to an OCaml developer's toolkit.
arjunguha has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
<Drup>
(I don't think it's implemented the way you would like, but .. :p)
sgnb has quit [Remote host closed the connection]
<def-lkb>
Drup: (chhhh)
q66 has joined #ocaml
angerman has joined #ocaml
<_cdruzac>
ok, random question: why does the value level language use standard function application notation, but the type language uses reverse polish notation?
<_cdruzac>
this sort of drives me crazy
<def-lkb>
hmm, because there are now higher-kinded types in ocaml
<def-lkb>
there are NO*
<def-lkb>
so, there is no type application, it's only type scheme instantiation
sgnb has joined #ocaml
<ggole>
Having four kinds of parameter syntax *is* a bit much, though.
<def-lkb>
four kinds?
<ggole>
f x y, Foo (X) (Y), f (x, y), ('a, 'b) foo
<ggole>
Er, third one should be captalised
<def-lkb>
F (X, Y) ? for value constructors ?
<ggole>
Yeah.
<def-lkb>
Yes, …
<ggole>
I'm comfortable with it now, but it was a bit eyebrow raising when I was first learning the language
<def-lkb>
I don't think that's fundamentally an issue. I am much more worried by the lack of higher-kinded types than by the weird syntax that comes with the replacement. Though Value constructors not being first-class values is also sometimes painful.
<def-lkb>
Also, the ?n different ways to introduce type variables when doing type ascription is really weird too.
wwilly has quit [Remote host closed the connection]
<ggole>
How many ways are there? 'a , 'a . foo, (type a)?
<def-lkb>
: type a
<ggole>
Mmm. The differences are pretty subtle, too.
<def-lkb>
Yes… This really feels afterthought. Well, it is :)
tane has joined #ocaml
tobiasBora has quit [Read error: Operation timed out]
<ggole>
Yeah, it seems like its really hard to evolve a language cleanly.