<mcc>
~f:(fun el -> is_inside_scene_element point el)
<mcc>
what does the - mean in this context
slash^ has joined #ocaml
govg has quit [Quit: leaving]
<Drup>
It's a label
slash^1 has quit [Ping timeout: 272 seconds]
<Drup>
you can name an argument to avoid mixing them up and to be able to apply it out of order
davine has joined #ocaml
hausdorff has quit [Remote host closed the connection]
hausdorff has joined #ocaml
hausdorff has quit [Ping timeout: 264 seconds]
<mcc>
oh, nice.
<mcc>
wait, hold on. the labeled arguments are for *curried* arguments…?
<Drup>
hum ?
govg has joined #ocaml
<Drup>
let f ~x ~y = x + 2 * y in f ~y:3 ~x:2
<Drup>
you can partially apply out of order with the labels too
<Drup>
(you can still apply without labels, if you apply completely, f 2 3 in the previous example)
<mcc>
that's… fascinating D:
<mcc>
huh :O
<Drup>
you don't like it ? x)
<bugabinga>
:) wish labels were more verbose
<mcc>
no, i actually do like it :O
<Drup>
more verbose ?!
<mcc>
stop naming your arguments single letter names! :P
<Drup>
that's for the example ! :>
<bugabinga>
lazy excuses <3
<Drup>
the typical example of nice labeling is "String.split string -> by:string -> string * string"
samrat has quit [Quit: Computer has gone to sleep.]
<Drup>
so you know by which string you are spliting.
<Drup>
the only issue with labels is that they don't mix very well with high order functions. Typically, "let f ~x = 3 * x in List.map f [ 1 ; 2 ]"
captain_furious has joined #ocaml
<Drup>
Which gives the very confusing "This expression has type x:int -> int but an expression was expected of type 'a -> 'b" :|
panini has joined #ocaml
serge has quit [Remote host closed the connection]
serge has joined #ocaml
<mcc>
one more question. am i correct if i assume ocaml has no significant whitespace?
<Drup>
yes
<panini>
yaa
<mcc>
yay
slash^ has quit [Ping timeout: 272 seconds]
mcc has quit [Quit: This computer has gone to sleep]
<adrien>
there's (*) :P
<reynir>
heh
<reynir>
I occasionally fall into the (*) trap
<reynir>
and then I feel silly
yomimono has joined #ocaml
<flux>
well, to be fair "significant whitespace" means "it is different to have 1 or some other non-zero amount of whitespace"
<adrien>
:)
<Drup>
reynir: the syntactic coloration should indicate you immediately about it.
serge has quit [Remote host closed the connection]
serge has joined #ocaml
ggole has joined #ocaml
tristero has quit [Ping timeout: 272 seconds]
<mrvn>
On my Amiga overclocking the FPU made it run cooler because it would sync with the cpu clock and had less busy waits to grab the bus.
<mrvn>
ups
<mrvn>
ewin
zpe has joined #ocaml
govg has quit [Quit: leaving]
manud_ has quit [Quit: Be back later ...]
larhat has joined #ocaml
Hannibal_Smith has joined #ocaml
serge has quit [Remote host closed the connection]
serge has joined #ocaml
<ggole>
Say you do the usual type _ any = Any : 'a t -> any to try to tame a GADT. Is it possible to write a function over the 'a t without using something like a witness?
<Drup>
no
<Drup>
also, there shouldn't be a _ here :)
<ggole>
Er, right. type any = Any : _ t -> any
<Drup>
also, I'm not sure it's a great way to "tame" a gadt :p
<ggole>
Isn't it a standard trick? (I have to admit, I don't get it yet.)
<Drup>
It depends of your definition of taming, I suppose
<Drup>
but you're just basically hiding it inside a black box
<ggole>
What I'd like to be able to do is write functions over GADTs of unknown type
<Drup>
ggole: what do your gadt look like ?
<ggole>
Obviously there would be some limitations, you wouldn't be able to do the f : type a . a t -> a thing
<ggole>
A toy AST sort of thing (it isn't actually a tree, but never mind that)
<Drup>
I hope this example satisfy you. I didn't write everything in order not to spoil you the fun :p
Submarine has quit [Ping timeout: 244 seconds]
IbnFirnas has joined #ocaml
<Drup>
you're going to have a lot of typing !FUN! with that, tell me how it goes, I'm quite curious :p
Submarine has joined #ocaml
alexherbo2 has quit [Ping timeout: 258 seconds]
<ggole>
Drup: hmm, this seems pretty obvious. I'm not quite sure why I was having trouble before.
<ggole>
Led astray by the error messages, maybe
<Drup>
ggole: the important part is the type annotation
<Drup>
you need and it's a bit delicate to guess it if you never saw it before
<ggole>
Yeah, I've seen it. Maybe the problem was that I was trying to annotate in the wrong way.
<ggole>
eg I was writing something like let foo (Any insn) = let insn : type a . a insn = insn in ...
<Drup>
1) the existential (Any) is not useful here
<ggole>
How do you put instructions in basic blocks then?
<Drup>
it's useful only if you want to hide the polymorphism (to put it in block, for example)
<Drup>
but not to define the function, on the contrary
<Drup>
2) you need to annotate on functions.
q66 has joined #ocaml
<ggole>
So have a fold_any which unwraps the existential, and applies an (annotated) fold
<ggole>
Right, that makes sense.
<ggole>
Hmm, this could be interesting
<Drup>
you can't write a fold like that
<Drup>
because the type traped inside the existential would escape
<Drup>
you can do iter and map (by rewraping after map)
<ggole>
Mmm.
<ggole>
(Actually because of mutable insn.def, I don't need map, but never mind that for now.)
<Drup>
well, you could need a duplication function :)
<ggole>
By fold I meant constant fold, sorry
<Drup>
ah, right :p
<ggole>
Yeah, bit confusing there :)
<Drup>
writing general functions on such datatype is not as easy as it seems
<ggole>
Right, I'm wondering how things like numbering will work
<Drup>
also, if you can, avoid using existentials
<ggole>
How to avoid that though? It's going to be necessary to do things like put insns and defs in sets and maps.
<Drup>
yes, it is, and you will occasionally bang your head against you head about it.
<ggole>
Hmm.
<Drup>
I advise you to write a function "unwrap" witch takes a witness and do dynamic checking, you will probably need it.
<Drup>
bang your head against you desk* :D
alexherbo2 has joined #ocaml
lordkryss has joined #ocaml
davine has quit [Ping timeout: 264 seconds]
<ggole>
I can't shake the feeling this should be easier.
<ggole>
Thanks for the help though, making a bit of progress.
<Drup>
ggole: Well, a good path to make it easier is to avoid having an existential in block
panini has quit [Quit: Leaving]
<ggole>
How can I do that?
<Drup>
Not sure
<ggole>
It seems tough. I could segregate into separate arrays for int and float instructions, but that will fall over dead as soon as I introduce something like records.
<Drup>
ggole: the other solution, which is probably simpler, but has other disadvantage, is to separate variables from instructions
<Drup>
you would gadt-type the variables, but not the instructions
<Drup>
it would confine the typing weirdness a bit
<Drup>
the downside is that you don't have the nice representation instruction = result of the instruction anymore.
<ggole>
Right.
<ggole>
Well, I'll consider it.
<Drup>
There are numerous papers on how to represent nice pure lambda-calculus like languages with GADTs but I don't recall anything for something like an SSA-like language
<Drup>
ask gasche about it, maybe he heard about something
<hnrgrgr>
"weatherReasons.ml"
<hnrgrgr>
...
davine has joined #ocaml
fraggle_ has quit [Remote host closed the connection]
serge has quit [Remote host closed the connection]
serge has joined #ocaml
<ggole>
Drup: I'm starting to think that my previous problem was due to an or-pattern
<ggole>
The type checker seems to love requiring those to be duplicated :/
ebzzry has quit [Remote host closed the connection]
<Drup>
ah yes
<Drup>
with gadt, you can't do or patterns for Variant with different types
<ggole>
Right, even if it doesn't matter
<ggole>
A | B -> () = no, A -> () | B -> () = yes. Sigh.
<Drup>
yes, the typechecker can't figure things out if you do
<Drup>
it's a known limitation :/
<ggole>
I imagine typing this stuff is delicate.
<Drup>
yes
araujo has quit [Ping timeout: 250 seconds]
<gdsfh>
http://paste.in.ua/10024/ -- why type information (from type ascription) doesn't propagate down, to match cases?
<gdsfh>
sorry, forget it.
shinnya has quit [Ping timeout: 260 seconds]
testcocoon has quit [Quit: Coyote finally caught me]
<Drup>
let f : [`Ok of a] -> _ = function `Ok A -> 1 ;;
<Drup>
propagates better
<ggole>
Works without error or warning in 4.02.1
<Drup>
oh, indeed, as ggole said, the original version works too
<ggole>
gdsfh: which version of ocaml are you using?
<gdsfh>
Drup: your version doesn't work too, but as I understand, my ocaml is too old for this trick. So, problem solved.
serge has quit [Ping timeout: 265 seconds]
tane has joined #ocaml
davine has quit [Ping timeout: 250 seconds]
SethTisue has joined #ocaml
shinnya has quit [Ping timeout: 244 seconds]
govg has joined #ocaml
samrat has joined #ocaml
parcs_ has left #ocaml ["WeeChat 1.1-dev"]
cespinoza has joined #ocaml
martintrojer has quit [Ping timeout: 244 seconds]
martintrojer has joined #ocaml
emery has quit [Ping timeout: 250 seconds]
emery has joined #ocaml
cespinoza has quit [Quit: Saliendo]
<ggole>
Hmm. I'd like to be able to express something like type a . (a key, a value) Hashtbl.t. That would help a lot with getting rid of existentials.
<ggole>
Is there a way to do that?
<ggole>
(I dont' think there is, but hope springs eternal.)
serge has joined #ocaml
bgianf has quit [Ping timeout: 256 seconds]
bgianf has joined #ocaml
<ggole>
Hard to see how you could do it, actually. You'd need the type system to somehow know about properties of the equality and hash operations.
Hannibal_Smith has quit [Quit: Sto andando via]
struktured has joined #ocaml
testcocoon has quit [Quit: Coyote finally caught me]
Nahra has joined #ocaml
darkf has quit [Quit: Leaving]
larhat has quit [Quit: Leaving.]
oscar_toro has joined #ocaml
govg has quit [Quit: leaving]
Aram has joined #ocaml
<Aram>
Hi. Is it possible to implement in OCaml a derivative operator? a function that takes input a function f (or expression), and outputs another function that when called with a particular parameter will calculate the derivative of f at that point?
<Aram>
Note that I don't mean calculate *numerically* (that's possible in any language). I don't want f (the original function) to be called (evaluated) at all when calling D(f)(x).
<Aram>
Also note that I don't mean "create a DSL that implements a computer algebra system". I don't want to create an Expr type and have various functions operate on that type (e.g. eval). I know that's possible. I want my f to be a genuine day-to-day ordinary function, not some special expression with a custom type.
<Aram>
Is that possible in OCaml? I know it's possible in various Lisps with macros, because they are homoiconic. For many example look in the Scheme code of Structure and Interpretation of Classical Mechanics. But I am curious if it's possible in statically typed languages.
<Aram>
It goes without saying that I do *not* know OCaml. Thanks.
ygrek has quit [Ping timeout: 245 seconds]
Arsenik has joined #ocaml
snyp has joined #ocaml
<snyp>
Error: No implementations provided for the following modules:
<snyp>
Cohttp_async referenced from ducksearch.cmx
<snyp>
I am getting this error
serge has quit [Remote host closed the connection]
<snyp>
Just trying out an example from Real World Ocaml.
<Aram>
Is there any non-homoiconic language that can implement a derivative operator taking a regular function? (no custom expression type that needs an eval function) and can produce results *without* calling the original function?
<ggole>
Aram: that's probably possible with camlp4
<Aram>
ggole: I could see how you could differentiate regular functions with camplp4, but I don't see how it could work with higher order functions (correct me if I misunderstand).
<ggole>
Oh right, I don't think you could do that if the (textual) definition of f wasn't available.
vfoley- has joined #ocaml
<ggole>
Mind you, I'm not sure you could do it reliably in Common Lisp either.
<Aram>
obviously there are limits, the set of differentiable functions is a small set of all possible functions that you can implement. if you have recursive functions, applying the mathematical algorithms doesn't make sense (even though you might still have well-defined derivatives).
<Aram>
on the other hands, you can usually differentiate functions involving conditionals, with care.
<Aram>
but that's actually one of my problems with the scheme implementations I've seen. Since we don't have static typing, these functions fail at run time.
<ggole>
I was thinking of the difficulty of getting the s-expression corresponding to a compiled function.
BitPuffin has quit [Quit: See you on the dark side of the moon!]
<ggole>
There's function-lambda-expression, but that isn't reliable (and fails to give you what you want on real implementations in practice, sadly)
<snyp>
nevermind, i was making a silly mistake
<snyp>
should've used the package cohttp.async instead of just cohttp
<snyp>
-_-
BitPuffin has joined #ocaml
nojb has joined #ocaml
Nahra has quit [Read error: Connection reset by peer]
Nahra has joined #ocaml
<Aram>
ggole: ok, related question. say you go with custom Expr types. Now is it possible to "compile" them instead of having to use eval?
tristero has joined #ocaml
q66 has quit [Quit: Leaving]
<ggole>
Not using the ocaml compiler: there's nothing like lisp's 'compile' function.
thomasga has joined #ocaml
q66 has joined #ocaml
mcclurmc has quit [Ping timeout: 245 seconds]
thomasga has quit [Quit: Leaving.]
davine has joined #ocaml
govg has joined #ocaml
Nahra has quit [Ping timeout: 244 seconds]
nojb has quit [Quit: nojb]
mcclurmc has joined #ocaml
slash^1 has joined #ocaml
slash^ has quit [Ping timeout: 272 seconds]
mcc has joined #ocaml
hausdorff has joined #ocaml
govg has quit [Quit: leaving]
snyp has quit [Quit: WeeChat 1.0.1]
<mcc>
I am still reading the manual, but I am confused what the difference between a record and a struct is.
<ggole>
struct ... end is a module definition
<mrvn>
a struct is a module with types and functions. A record is data.
<ggole>
struct isn't a separate thing from module
<ggole>
It's just syntax to describe a module.
<whitequark>
I don't think the manual even mentions "structs" as separate entities
<whitequark>
it's just records and modules
<mcc>
oh ok
SomeDamnBody has joined #ocaml
<SomeDamnBody>
I can't install zmq with opam...
<SomeDamnBody>
it gives me a compile error
<mcc>
the manual IME is a little terse :P
<SomeDamnBody>
uint64.h not found
<mcc>
IMO? whichever.
<whitequark>
it is.
<ggole>
mcc: if you want a more helpful walkthrough, consider real world ocaml
<ggole>
The manual is mostly a reference, with a bit of exposition thrown in here and there
<mcc>
ggole: literally reading it this second :D it's… … … i'm doing a lot better now that i'm working off it and not the manual.
<ggole>
Yeah, I can imagine.
<mcc>
still can't install camlp4 for some reason tho, so i can't use this Core library it likes, or utop...
<ggole>
Are you on the very latest ocaml? I think that broke camlp4 a bit.
zpe has quit [Remote host closed the connection]
<mcc>
i'm on the very latest ocaml on a very very old os x where a lot of software doesn't work right
zpe has joined #ocaml
<whitequark>
mcc: did you try opam install camlp4 and if yes, how does it error out?
<ggole>
If you're using opam, trying a slightly older version should be pretty easy.
<whitequark>
ggole: I don't actually think camlp4 is broken in opam.
<whitequark>
it's broken with some system installs.
<ggole>
Ah, that might be what I remember.
<whitequark>
so just `opam install camlp4` should totally work
<SomeDamnBody>
would there be any way to just retrograde the zmq to a version that flipping works
<SomeDamnBody>
it was already installed but I upgraded it from 1.1.0 to 1.1.1
<SomeDamnBody>
zmq install still failing...
<mcc>
so thinking out loud… it seems like if let can pattern-match, then let and match are doing fundamentally pretty similar things
<mcc>
like it seems like let PATTERN = VALUE in EXPR; is the exact same as saying match VALUE with PATTERN -> EXPR;
<mcc>
and for that matter it seems like you could replace either with (fun PATTERN -> EXPR) VALUE; ? and all three of these are the same except the sugar and the fact "let" only allows one match pattern? am i missing anything?
<whitequark>
you're absolutely correct
<mcc>
'k
<mcc>
*grumbles a little* this language has too much language in it
<whitequark>
it would be pretty annoying to use, were it much more minimalistic *shrug*
<whitequark>
SomeDamnBody: so what is the error message now?
<whitequark>
I'm not telepathic. I don't know what "still failing" means.
<mcc>
i want something exactly halfway between this and scheme :)
<SomeDamnBody>
whitequark, same error message
<SomeDamnBody>
uint64.h not found
<whitequark>
oh
<whitequark>
shitty package
<whitequark>
it uses oasis setup at install time
thomasga has joined #ocaml
<ggole>
mcc: the function will have slightly different typing.
<ggole>
Good old value restriction.
<ggole>
(And maybe some different warnings? I don't recall.)
<SomeDamnBody>
well upgrade won't work either now
<SomeDamnBody>
The brute-force exploration algorithm timed-out [59 states, 5s].
<whitequark>
mcc: can you show me whatever macports uses to install camlp4?
<whitequark>
recipe, makefile, whatever
<SomeDamnBody>
I'm still getting the same error
<SomeDamnBody>
omg... what the hell do I have to do to get that stupid header
<whitequark>
SomeDamnBody: I told you.
<whitequark>
it's a bug in zmq package.
<mcc>
whitequark: hm, i don't know if i can. i'll try!
<whitequark>
mcc: so basically the idea is that the camlp4 package installs a file called META *somewhere*
<whitequark>
I know where it is on Debian&co. I don't know where macports puts it.
<whitequark>
if you do "export OCAMLPATH=/path/to/that/file", everything will work.
<whitequark>
alternatively, you can do "opam switch 4.02.1", it will build the OCaml compiler, then it will build camlp4, all of that inside opam, and it will also work.
<mcc>
oh! well something i do know how to do is "port contents"
<mcc>
hm. it seems like there would be no downsides to that/
<mcc>
?
<SomeDamnBody>
I fixed it
<SomeDamnBody>
this works:
<mcc>
export OCAMLPATH=/opt/local/lib/ocaml/site-lib/camlp4/META # trying again
<whitequark>
path to the directory containing the file
hausdorff has quit [Remote host closed the connection]
<mcc>
still hitting errors-- camlp4.extend not found, camlp4.quotations not found.
<mcc>
...i ... don't need this right now.
<mcc>
whitequark do you think it would make sense if i just waited for your camlp4-stripping patches?
<mcc>
alternately, do you think this is important enough i should talk to the macports people and try to get it fixed?
<whitequark>
mcc: no (it could take month) and yes
<mcc>
i feel like it's explicitly their job to make this work.
<whitequark>
but
<mcc>
i could... i could potentially wait a month to get a working repl.
<whitequark>
right now you should probably just install the compiler via opam
testcocoon has quit [Quit: Coyote finally caught me]
<mcc>
*nod* it will take a while.
<whitequark>
less than a month, surely
<whitequark>
utop is massively useful for learning.
ggole has quit [Ping timeout: 264 seconds]
<mcc>
yeah, just, maybe when i go out later
<whitequark>
sure
testcocoon has joined #ocaml
<mcc>
ok so if i do opam switch 4.02.1
<mcc>
does that mean i can remove macports's camlp4 package?
manud_ has joined #ocaml
<struktured>
whitequark: what do you think will happen first? lwt drops camlp4 dependency, async drops camlp4 dependency, or camlp4 supports ppx extensions properly?
<whitequark>
mcc: yes
<whitequark>
struktured: um, I... have no idea. probably lwt.
<whitequark>
the only thing needed for lwt is to merge my PR, which is essentially ready
oscar_toro has joined #ocaml
<whitequark>
async is not going to drop camlp4 dep for, I think, around a year at least
<whitequark>
camlp4 support for ppx extension requires someone willing to dive into that ... codebase. I am certainly not motivated enough to fix it
<struktured>
I might have to dive on that bullet, although I was really excited to not learn calmp4
<whitequark>
I would advise against it
<struktured>
well eventually I might be blocked by a project which depends on ppx and async
<struktured>
but so far the compiler is surviving
<whitequark>
it's really not something you want to do, it's very much not trivial, and the more problematic camlp4 is, the less incentive it is to use it and the more incentive to migrate ;D
<whitequark>
does async have a camlp4 extension? I thought they did not
<struktured>
I couldn't find one, but async does suck it in (I believe through async-extra)
<struktured>
so maybe I'll be ok. I use to get an obscure Lambda.transl when building but that disappeared lately
<whitequark>
oh, sure, but I mean, if *your* code does not depend on camlp4, then there is no reason to get ppx support in camlp4
<struktured>
great, so maybe I'm good to go.
<whitequark>
should be
<whitequark>
and lwt supports ppx already.
<struktured>
great.
<struktured>
I wonder if the bitstring guys are doing a ppx port
<whitequark>
it was last active in 2008.
testcocoon has quit [Quit: Coyote finally caught me]
<whitequark>
oh, that's just the github project
hhugo has joined #ocaml
<struktured>
not a huge deal as you don't need the camlp4 extensions to use it
<flux>
I wish, though ;), that manual page installation came back into fashion some day
<flux>
I suppose I could actually work with opam to make that happen..
<whitequark>
page?
<whitequark>
o
<whitequark>
oh
<whitequark>
yeah, it should ideally be the part of opam-doc
emery has quit [Remote host closed the connection]
emery has joined #ocaml
hausdorff has joined #ocaml
dav has quit [Quit: leaving]
oriba has joined #ocaml
samrat has quit [Quit: Computer has gone to sleep.]
<MercurialAlchemi>
I thought "manual page" meant "load in utop and look at type signatures"
jao has joined #ocaml
jao has quit [Changing host]
jao has joined #ocaml
waneck has quit [Read error: No route to host]
waneck has joined #ocaml
manud_ has quit [Quit: Be back later ...]
<mcc>
hey does opam by default tend to ask questions?
<mcc>
like if i start opam switch 4.02.1 and leave the house, should i add a -uy
<mcc>
i mean a -y
manud_ has joined #ocaml
<MercurialAlchemi>
never seen anything bug me with questions so far
<MercurialAlchemi>
on the other hands, some things may fail to compile, which considerably more annoying
<mcc>
well, in that case i expect a halt.
dav has joined #ocaml
<dav>
is there a way to install opam from opam?
<whitequark>
mcc: yeah, do it
<whitequark>
mcc: or export OPAMYES=1
manud_ has quit [Ping timeout: 255 seconds]
<flux>
mercurialalchemi, I recommend you to try to make a useful Cmdliner app by just looking at the type signatures :)
<MercurialAlchemi>
flux: well, it is true that the simple act of printing type signatures may be enough to invoke the Deep Ones, or alternatively cause the spontaneous generation of a Scala compiler on your machine
manizzle has joined #ocaml
<MercurialAlchemi>
but that's the kind of thing that keeps your day interesting
thomasga has quit [Quit: Leaving.]
oriba has quit [Quit: oriba]
Hannibal_Smith has quit [Read error: Connection reset by peer]
rgrinberg1 has joined #ocaml
rgrinberg has quit [Read error: Connection reset by peer]
<artagnon>
whitequark: I returned after a couple of weeks to see the bindings functions filled in. How come it doesn't use ctypes like you said?
<whitequark>
note though that add_global_mapping is broken
AlexRussia has quit [Ping timeout: 256 seconds]
<artagnon>
Why so?
<artagnon>
Hold on. Let me first see what works for myself.
<whitequark>
bug in MCJIT
<artagnon>
Cool.
<artagnon>
Should be fun to dig up and fix :)
<whitequark>
someone else is going to do this
<artagnon>
Oh, okay.
<whitequark>
I'd give you a PR number but llvm.org is down
* artagnon
nods
<artagnon>
The Github mirror is fine though.
<whitequark>
oh
<whitequark>
PR20656
<whitequark>
artagnon: llvm.org/bugs.
<whitequark>
is not mirrored .
AlexRussia has joined #ocaml
ivg has quit [Ping timeout: 250 seconds]
ivg has joined #ocaml
ontologiae has joined #ocaml
ivan\ has quit [Ping timeout: 255 seconds]
<mcc>
whitequark: so now that i've done this switch 4.02.1 thing, it's reinstalling everything out of opam
MercurialAlchemi has quit [Ping timeout: 250 seconds]
<whitequark>
yes
<mcc>
whitequark: what happened to all the old libraries? like, physically, the binaries, where'd they go. is there cruft for a no-longer-used package repo somewhere i can delete off my hd?
<mcc>
i'm kinda low on disk space
<whitequark>
yes. ~/.opam/system
<whitequark>
opam switch remove system would do it
hhugo has joined #ocaml
<gdsfh>
whitequark: wtf. Streams are really useful without camlp4. Streams look like "lazy lists" wrt semantics, but with guarantees about freeing memory (so forgetting head of list in memory can't ever happen with streams, as they are "destructive").
manud_ has joined #ocaml
jonludlam has quit [Ping timeout: 272 seconds]
ivg` has joined #ocaml
<whitequark>
gdsfh: streams have very odd semantics which is 1) not what you expect 2) buggy
jonludlam has joined #ocaml
ivg has quit [Ping timeout: 255 seconds]
ivg` has quit [Client Quit]
ivg has joined #ocaml
yan_ has joined #ocaml
<gdsfh>
whitequark: i carefully read and understood stream.ml. Semantics is clear from doc. There are hacks, but streams work for my tasks good. Just like extlib's Enum, but without extlib. Maybe I just know how to work with streams, dunno. Also you have strange assumptions about my expectations.
q66[lap] has quit [Read error: Connection reset by peer]
q66[lap] has joined #ocaml
SethTisue has quit [Quit: SethTisue]
<mcc>
whitequark: ok... and that will... what will that do? that will remove the packages for OLD opam but not NEW opam?
<whitequark>
yep
<whitequark>
for old compiler
<whitequark>
not old opam
<mcc>
ok
captain_furious has quit [Ping timeout: 240 seconds]
<mcc>
"for opam packages installed under the old compiler but not for opam packages installed under the opam-installed compiler"?
<mcc>
is switch sort of like a python virtualenv i guess
<whitequark>
essentially
rgrinberg1 has quit [Quit: Leaving.]
<mcc>
ok
<mcc>
can a switch be limited to a single terminal session
<mcc>
or is it like… you're switching per user
manud_ has quit [Quit: Be back later ...]
<whitequark>
you can!
lordkryss has quit [Quit: Connection closed for inactivity]
<whitequark>
dav: oh I see, somehow opam database got out of sync with packages actually installed
<dav>
does the database not reside in ~/.opam ?
<dav>
i deleted the whole directory
<whitequark>
ok, that is one way to fix it
<dav>
no I mean, I already did that. I think that might have caused the problem..
malc_ has joined #ocaml
rgrinberg has joined #ocaml
<whitequark>
huh? certainly if you have removed the ~/.opam directory, ~/.opam/4.02.1/lib/lwt/META can not exist
<dav>
well i removed all of ~/.opam then install a few other packages
<dav>
one of them might have installed lwt
<whitequark>
ok
<whitequark>
this is possibly an opam bug
<whitequark>
if you can reproduce it from scratch, please report it at github.com/ocaml/opam/issues
<Drup>
gdsfh: you read and understood stream sources ? You're much better than I am then, because I personally can't understand what the hell is happening in that file
<Drup>
especially the part when it's doing Obj.set_field.
<Drup>
and the part where there are no less than 6 constructors to define lazy streams.
argp has quit [Ping timeout: 240 seconds]
argp has joined #ocaml
rgrinberg1 has joined #ocaml
rgrinberg has quit [Read error: Connection reset by peer]
<Drup>
(and it's not even fast ...)
struktured has joined #ocaml
shinnya has joined #ocaml
<gdsfh>
Drup: "You're much better than I am then" -- no, don't underestimate yourself, you just had no need to do it. And what about their speed -- how do streams look like in profiler's report?
<Drup>
they look 2 order of magnitude slower than sequences
<whitequark>
if an interface for something as trivial as sequences requires nontrivial effort to understand, it's a shitty interface
<whitequark>
especially that must not involve reading its source.
<Drup>
(if you want a one-by-one iterator, there is gen, which is almost as fast as sequence, and still dead-simple)
<struktured>
whitequark: bullet avoided, my entire project compiles now, depends on async + ppx_deriving_protobuf. I still wish I could use them together in utop too though.
<Drup>
struktured: in utop ?
<struktured>
struktured: yeah. in utop it explodes
<Drup>
async load some camlp4 in utop by default ?
<struktured>
Drup: I guess? If you're right maybe that's not so hard to disablew
<gdsfh>
"transfer a finite number of elements" -- streams unleash the full power of coinduction!
<Drup>
gdsfh: yes, gen is used for that
<Drup>
(things are much simpler when you don't try to conflate several use cases in one data structure :D)
<whitequark>
struktured: I actually think it's not trivial, sadly
<Drup>
(well, actually, you can also do infinite sequences, but since you can't stop and restart the iteration like you can with gen, it's less useful
<struktured>
whitequark: that is not ideal then, won't be able to debug my library with utop easily.
<gdsfh>
Drup: gen.mli looks nice. When I'll want to use streams next time, I'll check it out.
<Drup>
I agree, it's very nice :)
<whitequark>
struktured: complain to async ;p
<whitequark>
or use lwt.
<whitequark>
I don't think there is a reason async should depend on camlp4...
<struktured>
the irony is how I was previously using lwt, and switched to async about 2 months ago
<whitequark>
... don't tell me you did it to avoid camlp4
<struktured>
fortunately no, I almost went back to lwt because it seemed less dependent on it, actualy.
<whitequark>
why did you choose async over it?
<Drup>
in async_kernel META : "requires = "sexplib pa_ounit pa_test fieldslib bin_prot core threads herelib""
<struktured>
Drup: oh geez..how did I miss that when I looked at the same thing last week
zwer has joined #ocaml
<whitequark>
oh I see
zwer has left #ocaml [#ocaml]
<Drup>
struktured: fonctorise riakc over the async monad
<Drup>
so that it can runs on mirage ! :D
<whitequark>
struktured: sans async, the latter does look much nicer.
<struktured>
whitequark: I actually prefer lwt, but honestly only because I understood it faster
<Drup>
orbitz' libraries are usually quite well done.
<rgrinberg1>
pa_test is a camlp4 version of qtest :/
<rgrinberg1>
cool in theory
hausdorff has quit [Remote host closed the connection]
<orbitz>
what'd i do now?
<orbitz>
i'm terrible at documentation :)
<struktured>
Drup: I'll patch it and see what happens locally
<Drup>
orbitz: and advertisement :p
<orbitz>
:)
<orbitz>
Drup: thank you for the compliment, i try hard for decent APIs at leat (the implementation might be a bit ugly)
<struktured>
to Drup's point, I didn't know ocaml-riakc existed until someone actually told me about it
<orbitz>
I need to get back to my raft implementation, work has been draining
<Drup>
orbitz: isn't there an implementation by mfp already ?
<orbitz>
struktured: yeah, I assume Ashish pushed you towrads ocaml-riakc?
<orbitz>
Drup: yep, his looks quite nice as well.
<orbitz>
there are a few implementations out there.
<orbitz>
Mine is mostly to understand the algorithm and write ocaml code rather than any actual need
<Drup>
oh, right
<orbitz>
struktured: ocaml-riakc is pinned against an old version of Core right now too, I'm trying to fix that. I'll probably PR it to opam tomorrow
<struktured>
orbitz: you are correct sir, re: Ashish
<Drup>
orbitz: fonctorise, fonctorise !
<orbitz>
and I'd like to redo my protobuf library in terms of whitequark's since he hadnles the actual data better than me (i just want something API compatible with mine so I don't have to change code)
<struktured>
orbitz: I might do something like that right now, actually, although it may be more aggressive than your attentions.
<struktured>
*intentions
<orbitz>
struktured: for fixing the pinnings or protobuf?
<struktured>
orbitz: whitequark/ppx_protobuf replaces orbitz/protobuf . I didn't change any core deps
<orbitz>
ah
<orbitz>
i actually what to use orbitz/protobuf still, i just want orbitz/protobuf to be a wrapper around ppx_protobuf
<orbitz>
as in no ppx, I just want to make use of his protobuf impl
<struktured>
that sounds reasonable
<orbitz>
(I philosophically don't agree with autogenerating serialization code from type defintions)
<struktured>
orbitz: noted, perhaps I can build on top of your changes and depend on your lib rather than modifying it. when do you intend on making the wrapper?