<copy`>
In short, `FieldKey : Map.OrderedType` is too abstract
<copy`>
You can remove the type annotation
<copy`>
Or alternatively specify t: `FieldKey : (Map.OrderedType with type t = Field.field)`
<dh`>
right, just figured that
<dh`>
didn't realize you could put sharing constraints in there.
<dh`>
thanks!
<nathanielc>
How do I create an in_channel from a list of bytes? I am writing a test and want to provide a hardcoded list of bytes as an in_channel
<copy`>
nathanielc: I don't think you can do that, because an in_channel basically represents a file handle
<copy`>
So your best choice would be to read from a temporary file
<nathanielc>
ok, thanks that would explain why I couldn't figure it out :)
FreeBirdLjj has quit [Remote host closed the connection]
<dh`>
well, in many environments you can concoct fake files from in-memory byte streams
<dh`>
so it's not a stupid question :-)
smondet has quit [Remote host closed the connection]
jao has quit [Remote host closed the connection]
axiles has quit [Ping timeout: 252 seconds]
ygrek_ has quit [Ping timeout: 256 seconds]
brunoro has joined #ocaml
axiles has joined #ocaml
dh` has left #ocaml [#ocaml]
eh_eff_ has joined #ocaml
brunoro has quit [Ping timeout: 272 seconds]
FreeBirdLjj has joined #ocaml
rgrinberg has joined #ocaml
eh_eff_ has quit [Ping timeout: 252 seconds]
eh_eff_ has joined #ocaml
eh_eff_ has quit [Ping timeout: 256 seconds]
fraggle_ has joined #ocaml
nomicflux has quit [Quit: nomicflux]
togg has quit [Quit: togg]
FreeBirdLjj has quit []
AlexDenisov has joined #ocaml
FreeBirdLjj has joined #ocaml
brunoro has joined #ocaml
MercurialAlchemi has joined #ocaml
freusque has joined #ocaml
FreeBirdLjj has quit [Remote host closed the connection]
togg has joined #ocaml
brunoro has quit [Ping timeout: 244 seconds]
eh_eff_ has joined #ocaml
nomicflux has joined #ocaml
eh_eff_ has quit [Ping timeout: 264 seconds]
pierpa has quit [Ping timeout: 244 seconds]
freusque has quit [Quit: WeeChat 1.4]
AlexDenisov has quit [Quit: My Mac has gone to sleep. ZZZzzz…]
Sorella has joined #ocaml
FreeBirdLjj has joined #ocaml
kosh_ has quit [Ping timeout: 272 seconds]
FreeBirdLjj has quit [Remote host closed the connection]
kosh_ has joined #ocaml
FreeBirdLjj has joined #ocaml
FreeBirdLjj has quit [Ping timeout: 256 seconds]
FreeBirdLjj has joined #ocaml
copy` has quit [Quit: Connection closed for inactivity]
FreeBirdLjj has quit [Remote host closed the connection]
Mercuria1Alchemi has joined #ocaml
FreeBirdLjj has joined #ocaml
brunoro has joined #ocaml
eh_eff_ has joined #ocaml
nomicflux has quit [Quit: nomicflux]
brunoro has quit [Ping timeout: 264 seconds]
FreeBirdLjj has quit [Remote host closed the connection]
eh_eff_ has quit [Ping timeout: 244 seconds]
FreeBirdLjj has joined #ocaml
trrt has joined #ocaml
seangrove has quit [Ping timeout: 256 seconds]
FreeBirdLjj has quit [Ping timeout: 265 seconds]
seangrove has joined #ocaml
rgrinberg has quit [Ping timeout: 244 seconds]
<reynir>
!ocamloscope
tmtwd has quit [Ping timeout: 256 seconds]
for{} has joined #ocaml
ygrek_ has joined #ocaml
wxfdglm has joined #ocaml
seangrove has quit [Ping timeout: 272 seconds]
wxfdglm has quit [Ping timeout: 244 seconds]
togg has quit [Quit: togg]
seangrove has joined #ocaml
averell has quit [Ping timeout: 272 seconds]
tmtwd has joined #ocaml
togg has joined #ocaml
seangrove has quit [Ping timeout: 244 seconds]
brunoro has joined #ocaml
adi___ has quit [Ping timeout: 272 seconds]
brunoro has quit [Ping timeout: 265 seconds]
trrt has quit [Ping timeout: 240 seconds]
adi___ has joined #ocaml
seangrove has joined #ocaml
average has quit [Remote host closed the connection]
<chenglou>
Is there a way to use ocamlc -dparsetree without compiling and generating some artifacts + potential errors? I'm only using it to examine the AST. Can't use `ocaml` because I also need the `-pp` flag, which it doesn't expose
seangrove has quit [Ping timeout: 265 seconds]
average has joined #ocaml
tmtwd has quit [Ping timeout: 272 seconds]
dhil has joined #ocaml
orbifx has joined #ocaml
average has quit [Remote host closed the connection]
average has joined #ocaml
orbifx has quit [Ping timeout: 256 seconds]
seangrove has joined #ocaml
freusque has joined #ocaml
orbifx has joined #ocaml
seangrove has quit [Ping timeout: 252 seconds]
togg has quit [Quit: togg]
orbifx has quit [Ping timeout: 272 seconds]
FreeBirdLjj has joined #ocaml
dhil has quit [Ping timeout: 244 seconds]
brunoro has joined #ocaml
brunoro has quit [Ping timeout: 264 seconds]
freusque has quit [Quit: WeeChat 1.4]
kakadu has joined #ocaml
dhil has joined #ocaml
brunoro has joined #ocaml
brunoro has quit [Ping timeout: 265 seconds]
zpe has joined #ocaml
AlexDenisov has joined #ocaml
Algebr` has joined #ocaml
eh_eff_ has joined #ocaml
AlexDenisov has quit [Client Quit]
zpe has quit [Remote host closed the connection]
zpe has joined #ocaml
AlexDenisov has joined #ocaml
Simn has joined #ocaml
eh_eff_ has quit [Ping timeout: 272 seconds]
brunoro has joined #ocaml
zpe has quit [Ping timeout: 256 seconds]
Orion3k has quit [Ping timeout: 244 seconds]
<companion_cube>
Bluddy[m]: a sequence built on top of a persistent structure is persistent, too
<companion_cube>
(you just call `iter` several times)
brunoro has quit [Ping timeout: 265 seconds]
Orion3k has joined #ocaml
larhat has joined #ocaml
jwatzman|work has joined #ocaml
brunoro has joined #ocaml
brunoro has quit [Ping timeout: 265 seconds]
sfri has quit [Remote host closed the connection]
maufred has quit [Quit: leaving]
maufred has joined #ocaml
sfri has joined #ocaml
brunoro has joined #ocaml
ygrek_ has quit [Ping timeout: 244 seconds]
ocp has joined #ocaml
averell has joined #ocaml
roconnor has quit [Ping timeout: 252 seconds]
ocp has quit [Quit: Leaving.]
<Drup>
chenglou: "ocamlfind ppx_tools/rewriter"
zpe has joined #ocaml
mfp has joined #ocaml
AlexDenisov has quit [Quit: My Mac has gone to sleep. ZZZzzz…]
fraggle_ has quit [Remote host closed the connection]
AlexDenisov has joined #ocaml
for{} has quit [Remote host closed the connection]
Algebr` has quit [Ping timeout: 272 seconds]
fraggle_ has joined #ocaml
for{} has joined #ocaml
eh_eff_ has joined #ocaml
eh_eff_ has quit [Ping timeout: 265 seconds]
average has quit [Ping timeout: 244 seconds]
average has joined #ocaml
Algebr` has joined #ocaml
AlexDenisov has quit [Quit: My Mac has gone to sleep. ZZZzzz…]
for{} has quit [Remote host closed the connection]
AlexDenisov has joined #ocaml
average has quit [Remote host closed the connection]
brunoro has quit [Ping timeout: 264 seconds]
average has joined #ocaml
dhil has quit [Ping timeout: 256 seconds]
brunoro has joined #ocaml
eh_eff_ has joined #ocaml
brunoro has quit [Ping timeout: 265 seconds]
eh_eff_ has quit [Ping timeout: 272 seconds]
FreeBirdLjj has quit [Remote host closed the connection]
regnat[m] has quit [Remote host closed the connection]
lpw25[m] has quit [Remote host closed the connection]
barkmadley[m] has quit [Write error: Connection reset by peer]
M-ErkkiSeppl has quit [Write error: Connection reset by peer]
M-jimt has quit [Remote host closed the connection]
M-martinklepsch has quit [Remote host closed the connection]
timclassic has quit [Remote host closed the connection]
Bluddy[m] has quit [Remote host closed the connection]
srenatus[m] has quit [Remote host closed the connection]
M-Illandan has quit [Write error: Broken pipe]
M-pesterhazy has quit [Write error: Connection reset by peer]
njij has joined #ocaml
obadz has quit [Ping timeout: 244 seconds]
for{} has joined #ocaml
lpw25[m] has joined #ocaml
obadz has joined #ocaml
M-jimt has joined #ocaml
regnat[m] has joined #ocaml
barkmadley[m] has joined #ocaml
M-pesterhazy has joined #ocaml
M-Illandan has joined #ocaml
M-martinklepsch has joined #ocaml
srenatus[m] has joined #ocaml
Bluddy[m] has joined #ocaml
timclassic has joined #ocaml
M-ErkkiSeppl has joined #ocaml
kakadu has quit [Ping timeout: 256 seconds]
FreeBirdLjj has joined #ocaml
brunoro has joined #ocaml
Bluddy[m] has quit [Ping timeout: 272 seconds]
Bluddy[m] has joined #ocaml
BitPuffin has joined #ocaml
regnat[m] has quit [Ping timeout: 272 seconds]
M-jimt has quit [Ping timeout: 272 seconds]
regnat[m] has joined #ocaml
M-jimt has joined #ocaml
_andre has joined #ocaml
fryguybob has quit [Remote host closed the connection]
M-ErkkiSeppl has quit [Ping timeout: 272 seconds]
lpw25[m] has quit [Ping timeout: 272 seconds]
jbrown has quit [Ping timeout: 272 seconds]
lpw25[m] has joined #ocaml
M-ErkkiSeppl has joined #ocaml
jbrown has joined #ocaml
srenatus[m] has quit [Ping timeout: 272 seconds]
srenatus[m] has joined #ocaml
silver has joined #ocaml
<Bluddy[m]>
companion_cube: it seems like sequences are far more persistent in general than enums
<companion_cube>
yes
<companion_cube>
(it's not always easy to predict the cost of running them twice, though; might perform some computation twice)
<Bluddy[m]>
even building a sequence from scratch is persistent
ttfh has joined #ocaml
<companion_cube>
ah, yes
<Bluddy[m]>
pretty cool. So what's their 'limitation' compared to enums?
<companion_cube>
some operations are not possible (not without converting to, say, lists)
<companion_cube>
the operations that involve interrupting the iteration and coming back to it later
<companion_cube>
(merge, zip, etc.)
<companion_cube>
cartesian product is easy though
<Bluddy[m]>
hmm... interesting
<companion_cube>
so, it's good for "foreach" stuff, not for manual iteration, if you see what I mean
<Bluddy[m]>
how's performance compared to enums?
<companion_cube>
depends on what exactly you do
<companion_cube>
Sequence is extremely fast for map/filter/flat_map/product/etc.
<companion_cube>
(really really fast :p)
<Bluddy[m]>
right, since it's just an iteration
<companion_cube>
yes
<companion_cube>
`let map f seq yield = seq (fun x -> yield (f x))` ← this is map
<companion_cube>
`let flat_map f seq yield = seq (fun x -> f x yield)` so simple ^^
<companion_cube>
(for fold, however, you have to pay a small price for the write barrier because it uses a reference)
<ttfh>
what is this sorcery?
<ttfh>
(missed start of conversation)
<Bluddy[m]>
there should really be more material out there about this
<companion_cube>
`type 'a sequence = ('a -> unit) -> unit` a style of iterator that is easy and fast
<Bluddy[m]>
since this is the most efficient way of coding in OCaml
<companion_cube>
I gave a talk on sequence a while ago
<companion_cube>
the video must be somewhere on mozilla's website (it was a mozilla-hosted meetup)
* reynir
bookmarks
<ttfh>
oh
<Bluddy[m]>
nice
<Bluddy[m]>
still, should be in RWO
<companion_cube>
well, Core has its own iterators and they are different…
eh_eff_ has joined #ocaml
<Bluddy[m]>
was looking it up and thought janestreet core_kernel died... they're already using base
eh_eff_ has quit [Ping timeout: 272 seconds]
<Bluddy[m]>
ok so Core uses functions instead of laziness
<Bluddy[m]>
and a much more complex data structure
<Bluddy[m]>
but it's the same idea
<Bluddy[m]>
I think
<Drup>
core.sequence is more akin to gen
<Drup>
(in term of both expressiveness and speed)
<Drup>
(actually, it's more similar to batSeq, but all those are quite similar in the end)
<Bluddy[m]>
so confusing
<Drup>
yeah, the naming was a bit annoying
copy` has joined #ocaml
<Bluddy[m]>
ok so are both BatEnum and BatSeq basically the same idea? They both seem to be (() -> 'a)
for{} has quit [Quit: Leaving]
<Bluddy[m]>
I don't understand why they have different semantics
for{} has joined #ocaml
<Drup>
BatSeq is not destructive
<companion_cube>
batSeq is `unit -> nil|cons('a*'a batseq)`
<companion_cube>
i.e. a list with a function giving the tail (so it's delayed)
<companion_cube>
Core.Sequence is basically the same but with a GADT instead of a closure; otherwise exactly the same
<Bluddy[m]>
and Bat.Enum's next label is the same as sequence, except it tries to use state as much as possible, and therefore has no guarantees about old values
<Bluddy[m]>
?
<Bluddy[m]>
sequence = BatSeq
<companion_cube>
no, BatEnum is not the same as sequence either
<companion_cube>
(sequence has no `next` function anyway, if that's what you're asking)
<Bluddy[m]>
it has a next function that's unit -> 'a
<Bluddy[m]>
companion_cube: I meant BatEnum is really similar to BatSeq
libertas has joined #ocaml
<Bluddy[m]>
nobody else has Containers
<Bluddy[m]>
' sequence
<companion_cube>
ah, well, BatEnum is like a reference to BatSeq where you forget the old list, so it's not exactly the same either
<companion_cube>
it's `unit -> 'a` but calling the function twice returns two successive values
<companion_cube>
whereas with batSeq you get the same node
<companion_cube>
(i.e. it behaves like a list)
<Bluddy[m]>
yes
<Bluddy[m]>
so nobody has your sequence. Why?
<Bluddy[m]>
why doesn't janestreet want to implement it?
<benmachine>
one possible reason is that it's so simple you don't often need an actual module for it
<companion_cube>
Bluddy[m]: well, if you export `iter`, it's compatible with sequence
<companion_cube>
(but I still like to have convenience functions like `of_seq`)
<benmachine>
like, how often do you actually pass around a partially-applied iter function, that's approximately how often you'd use this sequence type
<companion_cube>
why no other big lib exports it, well, they might not need it, I don't know
kakadu has joined #ocaml
<companion_cube>
benmachine: not really
<companion_cube>
if you use Sequence, you write code slightly differently
<Bluddy[m]>
it's extremely useful
<Bluddy[m]>
i mean our goal is to reduce allocation
<companion_cube>
1 -- n |> Sequence.flat_map f |> Sequence.filter foo |> Sequence.take 10 |> Sequence.to_list
<companion_cube>
with a List this is far less efficient, for instance
<benmachine>
wait, Sequence.take?
<benmachine>
I guess you can do that with exceptions
<Bluddy[m]>
Right, and you're hiding the imperative nature of it
<Bluddy[m]>
the point is, these iterator types exist to do what fusion does for haskell
<companion_cube>
benmachine: you guessed right ;)
<companion_cube>
everything looks functional, but the implementation is imperative at places (take, fold)
<companion_cube>
and Sequence.persistent :]
<companion_cube>
(which puts every element in an optimized structure in memory; then you can iterate on it a lot without doing the computations again)
<benmachine>
right
<benmachine>
I guess I never feel myself needing this kind of thing because either I don't care much about performance and use lists or I do in which case I'm willing to compromise on prettiness
<companion_cube>
I have a funny but disgusting piece of code where I use sequence to enumerate all the possible ways of String.capitalize broken utf8 text that I String.lowercase'd before
<benmachine>
it's nice to have both, of course, but it never feels like you *need* it
<companion_cube>
yeah, I can understand
<benmachine>
well. actually I guess that I never feel myself needing this kind of thing because I just don't care about performance
<Bluddy[m]>
I disagree
<companion_cube>
for the kind of stuff I write it's very useful; if you don't traverse trees a lot, less useful
<Bluddy[m]>
you always want to write performant code if you can
<companion_cube>
Bluddy[m]: I have some ASTs where `subterms : ast -> ast Sequence.t` \o/
<Bluddy[m]>
you never know who will need your code
<benmachine>
I know people who care about allocations, but I'm not one of them :P
<benmachine>
Bluddy[m]: if I'm not writing a library I know
maufred has quit [Ping timeout: 272 seconds]
<Drup>
benmachine: note that with flambda, sequence is basically equivalent to handwritten for loops
<Drup>
(just so much nicer)
<benmachine>
Bluddy[m]: and in any case, I'd usually prefer a featureful and correct library to a fast one, so it's about priorities
<Bluddy[m]>
correctness is the priority
<benmachine>
Drup: sure. if I really hated writing for loops I'd be happier about that :P
<Bluddy[m]>
but someone will need to use your library and take a small performance hit
<benmachine>
Drup: (I'm still quite happy about it)
<Bluddy[m]>
we should all be using these paradigms
<benmachine>
Bluddy[m]: I don't disagree. I've been more tyring to justify why no-one's excited enough about this to put it in core, than actually to say it shouldn't be done
<Drup>
benmachine: you really want to write the composition of flat_map and take with a for loop ?
<Bluddy[m]>
companion_cube: so the iterator you're trying to put in the stdlib is supposed to bridge between Core.Sequence and BatSeq?
<companion_cube>
benmachine: I can `filter` on Queue.t or Hashtbl.t, that's sometimes useful :)
<companion_cube>
Bluddy[m]: yeah, it's isomorphic to Core.Sequence actually
<libertas>
I understand it's pattern matching to get information out of a record type
FreeBirdLjj has quit [Remote host closed the connection]
<libertas>
but, what are the first and second 'x' there?
<benmachine>
{ x } is shorthand for { x = x }
<libertas>
and why is the first x between {}? because it's itself another record, although we're only interested in the abcissa?
AlexDenisov has quit [Max SendQ exceeded]
<benmachine>
which in this case means "match the value of field x against the pattern which coincidentally is also x"
<benmachine>
your line is equivalent to `let get_min_x { left_upper_corner = { x = result } } = result
<benmachine>
§
<benmachine>
...ignore that §
AlexDenisov has joined #ocaml
fraggle-boate has joined #ocaml
<benmachine>
in fact it's also approximately equivalent to let get_min_x t = t.left_upper_corner.x
<benmachine>
("approximately": it will give you different warnings if you have certain warnings enabled)
BitPuffin has quit [Read error: Connection reset by peer]
AlexDenisov has quit [Max SendQ exceeded]
AlexDenisov has joined #ocaml
<libertas>
benmachine: thanks, it's not yet totally assimilated by my cells, but it will with your great help!
maufred has joined #ocaml
FreeBirdLjj has joined #ocaml
<libertas>
benmachine: just one thing more. Why does get_min_x expect a box type, as only left_upper_corner is specified in the pattern matching and not right_lower_corner?
FreeBirdLjj has quit [Ping timeout: 265 seconds]
average_ has joined #ocaml
average has quit [Read error: Connection reset by peer]
njij has quit [Quit: Page closed]
nomicflux has joined #ocaml
AlexRussia_ has quit [Ping timeout: 252 seconds]
kakadu has quit [Ping timeout: 252 seconds]
kakadu has joined #ocaml
<benmachine>
libertas: well, fields that aren't named are just ignored
<benmachine>
in the pattern, I mean
<benmachine>
there's a warning you can enable which complains when you leave any fields out
<benmachine>
so that you would have to write let get_min_x { left_upper_corner = { x; _ }; _ } = x
<benmachine>
where the _ mean "there are more fields here but I'm omitting them"
<benmachine>
I can't remember which warning number it is though
pierpa has joined #ocaml
eh_eff_ has joined #ocaml
Mercuria1Alchemi has quit [Ping timeout: 272 seconds]
govg has joined #ocaml
eh_eff_ has quit [Ping timeout: 256 seconds]
<kakadu>
Folks,can I specify two preprocessors in myocamlbuild?
<kakadu>
At the moment I have
<kakadu>
flag ["ocaml"; "use_m4"] (S [ A"-pp"; A"m4 src/macro.m4" ; A"-pp"; A"camlp5o pr_o.cmo camlp5/pa_gt.cmo" ]);
<kakadu>
And it is exapanded into this bad command line.
<Drup>
I'm not sure it's completely uptodate, but the basics should be there
<rand__>
I also made an issue @ github with a list of other impracticalities of the makefile - seems like it should be remade, or I should just make the setup manually
<rand__>
will try that out - thanks
<Drup>
Yes, I saw it
<Drup>
I quite agree with you, I don't like this template at all, but I've got no time to dedicate to it whatsoever :(
<rand__>
Ok.. you also seem like a very small team developing on it
<Drup>
a bit less than 10 people, nowadays
<rand__>
I saw somewhere that you where seeking people developing on it, can't remember where now - but one need have > master degree in CS to apply?
<rand__>
>=
<Drup>
not my call :)
<rand__>
ok (:
brunoro has quit [Ping timeout: 265 seconds]
Denommus has joined #ocaml
mengu has joined #ocaml
<rand__>
Drup: cool - whitequarks example works if you change 'config/server.xml' to point to 'ocsigenserver.ext.ocsipersist-sqlite' instead of 'ocsigenserver.ext.ocsipersist-dbm' - thanks again
sz0 has joined #ocaml
brunoro has joined #ocaml
kamog has quit [Quit: Konversation terminated!]
brunoro has quit [Ping timeout: 272 seconds]
sh0t has quit [Ping timeout: 252 seconds]
nomicflux has joined #ocaml
<Bluddy[m]>
is there anything special about std.ml?
<Bluddy[m]>
does it have any significance?
<def`_>
what is std.ml ?
<Bluddy[m]>
a file used for module aliasing?
<Bluddy[m]>
is it loaded automatically or something?
<def`_>
no, there is nothing special about std
<def`_>
it is a Janestreet convention if you are talking about Core
<Bluddy[m]>
ok that makes sense
brunoro has joined #ocaml
sh0t has joined #ocaml
brunoro has quit [Ping timeout: 264 seconds]
Algebr` has quit [Ping timeout: 252 seconds]
brunoro has joined #ocaml
MercurialAlchemi has quit [Ping timeout: 244 seconds]
brunoro has quit [Ping timeout: 264 seconds]
Mandus has quit [Read error: Connection reset by peer]
brunoro has joined #ocaml
zpe has quit [Remote host closed the connection]
zpe has joined #ocaml
brunoro has quit [Ping timeout: 264 seconds]
zpe has quit [Ping timeout: 252 seconds]
brunoro has joined #ocaml
rand__ has quit [Quit: leaving]
brunoro has quit [Ping timeout: 272 seconds]
brunoro has joined #ocaml
brunoro has quit [Ping timeout: 252 seconds]
kakadu has quit [Remote host closed the connection]
for{} has quit [Remote host closed the connection]
brunoro has joined #ocaml
Denommus has quit [Quit: going home]
brunoro has quit [Ping timeout: 264 seconds]
TheLemonMan has quit [Quit: "It's now safe to turn off your computer."]
orbifx has joined #ocaml
brunoro has joined #ocaml
<orbifx>
is there a list of unikernel applications based on MirageOS?
brunoro has quit [Ping timeout: 244 seconds]
brunoro has joined #ocaml
SpiceGuid has joined #ocaml
brunoro has quit [Ping timeout: 256 seconds]
brunoro has joined #ocaml
SpiceGuid has quit [Quit: ChatZilla 0.9.92 [SeaMonkey 2.40/20160120202951]]
freusque has joined #ocaml
emias has quit [Ping timeout: 240 seconds]
emias has joined #ocaml
freusque has quit [Ping timeout: 256 seconds]
smondet has quit [Ping timeout: 265 seconds]
agarwal1975 has quit [Quit: agarwal1975]
brunoro has quit [Ping timeout: 272 seconds]
orbifx1 has joined #ocaml
brunoro has joined #ocaml
eh_eff_ has quit [Ping timeout: 272 seconds]
brunoro has quit [Ping timeout: 272 seconds]
smondet has joined #ocaml
brunoro has joined #ocaml
brunoro has quit [Ping timeout: 272 seconds]
eh_eff_ has joined #ocaml
octachron has quit [Quit: Leaving]
Simn has quit [Quit: Leaving]
orbifx1 has quit [Quit: WeeChat 1.5]
M-Illandan has quit [Quit: node-irc says goodbye]
brunoro has joined #ocaml
brunoro has quit [Ping timeout: 264 seconds]
mengu has quit []
ydl has joined #ocaml
<ydl>
is there a standard "dynamic" array that can be efficiently appended to in ocaml/jane street core?
<ydl>
something like c++'s vector. alternatively a list with efficient append. doesn't have to be an immutable structure, but if it presented a functional interface that would be nice.
<orbifx>
ydl: what's wrong with lists?
<copy`>
I'm using CCVector from containers. It would be a new dependency, but a light one
<ydl>
orbifx: i'd like to be able to build from front to back efficiently. also fast random access would be nice, but not necessary.