Arach has quit [Remote host closed the connection]
Arach has joined #ocaml
<DantesNewHaircut>
You still have a defined evaluation order and stuff, it just makes functions like map not accept them because the order is not defined.
<DantesNewHaircut>
Hmm, that pure/impure distinction that has in mind is different from my own though
<Drup>
and if you want to map with an impur function, you need a monadic map
<Drup>
and then all things go to hell and you need haskell-like monadic stuff
<Drup>
and I don't want this in my ocaml.
<DantesNewHaircut>
You don't need a monadic map. You just need a map function which defines an order.
<DantesNewHaircut>
Scheme calles this map-in-order which is just map, except guaranteed to map from left to right
<Drup>
your view is too simple :)
<DantesNewHaircut>
Well, what's the catch then?
kyrylo has joined #ocaml
chris2 has joined #ocaml
<Drup>
as I told you, there is multiple ways to be impur
<Drup>
and you *will* need combinators at some point
<DantesNewHaircut>
Well, obviously a pure function cannot call any impure functions in its body.
<DantesNewHaircut>
Then it must be marked as impure
malvarez has quit [Remote host closed the connection]
manizzle has quit [Ping timeout: 252 seconds]
zxqdms has joined #ocaml
yacks has joined #ocaml
travisbrady has joined #ocaml
aggelos has joined #ocaml
aggelos has quit [Ping timeout: 252 seconds]
zRecursive has joined #ocaml
ygrek has joined #ocaml
philtor has joined #ocaml
dfarm has quit [Ping timeout: 252 seconds]
mcclurmc has joined #ocaml
travisbrady has quit [Quit: travisbrady]
travisbrady has joined #ocaml
philtor has quit [Ping timeout: 252 seconds]
ygrek has quit [Ping timeout: 245 seconds]
talzeu___ has quit [Read error: Connection reset by peer]
talzeus_ has joined #ocaml
ygrek has joined #ocaml
shadynasty has quit [Ping timeout: 245 seconds]
talzeus_ has quit [Read error: Connection reset by peer]
manizzle has joined #ocaml
jao has quit [Read error: Operation timed out]
kyrylo has quit [Ping timeout: 240 seconds]
siddharthv_away is now known as siddharthv
zpe_ has quit [Remote host closed the connection]
zpe has joined #ocaml
zpe has quit [Read error: Connection reset by peer]
zpe has joined #ocaml
travisbrady has quit [Quit: travisbrady]
mcclurmc has quit [Remote host closed the connection]
<gasche>
would you agree to use that instead of a mailing-list?
malo has joined #ocaml
<adrien>
I've actually been wondering if the answers were about "where do you prefer to review patches" or "where do you prefer to send your patches for review"
<adrien>
there's also as many "never used git-send-email/don't care" as in favor of github
<adrien>
I'm not opposed to github
<adrien>
well, I am
<adrien>
but I'll make with, probably
<adrien>
I need to have a deeper look
<adrien>
is it at least workable for me
<adrien>
and also: are there reviewers?
<adrien>
I'm unavailable until after fosdem; at which point I'll probably have work for a few more days
<adrien>
and then I'll need to start patches again
<gasche>
well
<gasche>
"are there reviewers" is the hard question anyway
<adrien>
probably adding "GNUMakefile" and "BSDMakefile" and "cd dir/ && make" (pmake will prefer bsdmakefile and gnu make will prefer gnumakefile)
<gasche>
the hope is that by exprerimenting with a new review medium will attract reviewers
<adrien>
(and then merge the .nt ones)
<gasche>
but that is a wild guess indeed
<gasche>
-by *experimenting
<adrien>
gasche: yeah, I'll (try to) go where reviewers are
<adrien>
github's UI tend to drive me mad though
<gasche>
do not have too-high hopes of a load of people eager to review GNUMake vs. BSDmake portability patches, though
<nicoo>
adrien: There is a somewhat-sane CLI interface for GitHub
<gasche>
I think sane humans tend to avoid working on that part :-'
nikki93 has quit [Remote host closed the connection]
<adrien>
(as for people complaining about mantis (not for bug reviews), I tend to believe they don't try to see how it can be a fairly good tool on the side of maintainers, and how it can be nice for larger projects but anyway)
<gasche>
(maybe it's a field such that the... qualities that make you interested in it are exactly those that make you prefer mailing-lists over github)
<adrien>
nicoo: there's a CLI-interface to phabricator too
<nicoo>
gasche: Ask companion_cube to invent a dependency description language which compiles to both :)
<adrien>
nicoo: it tends to be hated
<gasche>
I also don't get the hate on mantis
<adrien>
gasche: that's the point! non portability patches for gnu/bsd make
<adrien>
separate the stuff
<adrien>
let each of them decide what to load
thomasga has joined #ocaml
<nicoo>
adrien: I don't know about the phabricator CLI, but I use the one for GitHub (though, as I said, I do not lug around loads of PRs/Issues) and it is fine.
<adrien>
gasche: and build system stuff doesn't make me terribly happy but I tend that's required to reach the goal
<gasche>
I'm not criticizing
<adrien>
nicoo: can I send 20 patches and get comments in a proper format?
<adrien>
nicoo: without a proprietary tool?
<gasche>
I'm happy there is someone interested in that stuff (and happy to stay away from it myself)
<nicoo>
adrien: It's what I'm currently checking (and the CLI is open-sources and uses only the public, documented API AFAIK)
<gasche>
I'm just saying you shouldn't count on ten more people like you appearining, whatever the review medium is
<gasche>
hm, my english is really terrible today
<gasche>
(I think my english is getting *poorer* over time, for some reason I don't quite understand)
<adrien>
lack of practice
<adrien>
I'm not after ten more people, I just want to have a few people who can review and not put all the work on one people at once
<nicoo>
gasche: I noticed that my French actually got poorer over the last 6 months (where I hadn't had face-to-face contact with native speakers)
Thooms has joined #ocaml
<adrien>
and I think I know why I prefer mailing-lists in the end: I see patch reviews as discussions and I doubt I'll get many codestyle or implementation critics
<adrien>
more about the approach
<gasche>
I remember previous review rounds of your patches had a mix of both, with also fairly specific detailed comments
<adrien>
at which point it's not really code review but design review, i.e. mail or talking live
<adrien>
yup, I definitely had some wrong implementation things but not that many or not that big
<gasche>
github has a reasonable discussion interface
<gasche>
I'm less sure about how it handles you proposing a new patchset
<adrien>
as long as I can avoid javascript, flash, css, stupid animations and I can use a vim, I'm happy
<gasche>
(there is some automatic logic to update a pull request, but it's not always as clear as a new mail)
<gasche>
why don't you send a PR to Batteries as a test?
<gasche>
:]
<adrien>
because batteries is perfect; there's nothing to complain about!
<adrien>
:D
<nicoo>
gasche: Basically, if you PR a branch, then push things to it, the PR is automatically updated and participants notified
FreeArtMan has joined #ocaml
<nicoo>
If you force-push to it, dropped commits are marked as obsolete (as are the in-code commentaries) but still visible if you wish to.
_andre has joined #ocaml
<adrien>
need to commut to the office
* nicoo
projects adrien into a commutative ring.
<gasche>
nicoo: I find that partially-destructive way to do things is confusing
<gasche>
also this encourages adding additional commits for reviewer-suggested fixes
<gasche>
I personally prefer to get nice patchqueues, and the history is better that way
<nicoo>
gasche: I also dislike the force-push approach. It is clearer what changed after discussion if the whole commit isn't rewritten every time.
<rgrinberg>
also participants aren't notified after force push
<gasche>
in any case
<nicoo>
rgrinberg: I wasn't aware of that. :o
<gasche>
the contribution/review process of the OCaml distribution is severely bandwidth-limited right now
<gasche>
if using github PR (or a mailing-list) can help with that, it's a good idea *irrespectively* of technical aspects; the point is to make people want to help
<rgrinberg>
gasche: there has been a few projects that switched to github recently and not so recently. ocsigen for example, how did it work out for them?
<rgrinberg>
just a data point to consider
<rks`>
rgrinberg: nobody contributed before
<rks`>
nobody does now.
<rgrinberg>
also, is ocamlbuild coming to github? :D
<jpdeplaix>
:DDD
<jpdeplaix>
<3 rks`
<rks`>
that was just a wild guess :-'
<rgrinberg>
well maybe there's at least more bug reports :D
<darklajid>
Really like ocaml so far, but some F# additions .. would be neat. seq {} for easy lazy sequences, async/parallel - but oh, the speed is so much nicer here and the startup time isn't even funny
FreeArtMon has joined #ocaml
<gasche>
I would like ask avsm about using github PR, though
<nicoo>
Kakadu: Well, I have to admit that Mantis is more daunting that most patch review systems; on the other hand, submitting a patch isn't the hardest part, so I would conform to whatever the developpers find convenient.
jonludlam has joined #ocaml
<gasche>
in particular, I am not sure people realize that even though patches would be discussing on github, PR would *not* be merged directly in the mirror
<gasche>
(which would remain read-only)
<rgrinberg>
mantis is dire need of some ninja node js bootstrap magic :/
<rgrinberg>
is in
<gasche>
I think people don't realize that, but I'm not sure how much it would impact the workflow
skchrko_ has quit [Read error: Operation timed out]
<nicoo>
gasche: Since you can close a PR/Issue from a commit regardless of where it comes from, it shouldn't impact the workflow overly much (for people submitting patches, at least)
FreeArtMan has quit [Ping timeout: 272 seconds]
<jpdeplaix>
before the migration, contributions were 1 or 2 by years and bug reports were about 10 by years. Now it's more like over 10/20 a month each
thomasga has quit [Quit: Leaving.]
avsm has joined #ocaml
<gasche>
jpdeplaix: but there is hhugo now
<gasche>
which single-handedly probably makes any github impact neglectible
<gasche>
avsm: I wanted to ask you about the patch-review-on-the-github-mirror idea
<rks`>
gasche: would he have contributed if it weren't on github though?
<gasche>
I'm pretty sure he would
<gasche>
he works on an Ocsigen codebase professionally
<rks`>
(I believe he already contributed to some projects before ocsigen move to github)
yacks has joined #ocaml
<rks`>
(but I don't know if he contributed to ocsigen, but it might be unrelated)
<rks`>
(so nevermind)
<rks`>
ok
nikki93 has joined #ocaml
skchrko_ has joined #ocaml
<gasche>
he massively contributed to js_of_ocaml, which is probably what takes the larger part of jpdeplaix's changecount
jonludlam has quit [Ping timeout: 252 seconds]
<nicoo>
adrien: I checked. The `hub` CLI tool doesn't allow reading/writing comments on a pull-request (or an issue), but there is a public API for that.
<adrien_o1w>
bleh
<adrien_o1w>
thanks for checking
adrien_o1w is now known as adrien_oww
mcclurmc has joined #ocaml
nikki93 has quit [Ping timeout: 252 seconds]
<adrien_oww>
Kakadu: I've already seen the codereview tools used by qt/kde and I find them fairly nice
<adrien_oww>
much nicer than github's UI and functionalities
<adrien_oww>
Kakadu: the issue is setting the service up and maintaining it
<adrien_oww>
quite clearly we're not going to find anyone who would do that
<adrien_oww>
(if people even don't want a separate subscription/password for a tool they use _very_ often, I don't think we'll find anyone willing to do admin stuff)
<adrien_oww>
(NB: that doesn't apply to gitlab which is notoriously difficult and annoying to setup)
<nicoo>
adrien_oww: According to the ones maintaining the Exherbo infra, gerrit isn't annoying/cumbersome to maintain. (Note that it is only ear-say, as I'm not on the infra team)
mcclurmc has quit [Ping timeout: 245 seconds]
<adrien_oww>
nicoo: I only mentionned gitlab's setup annoyance because avs-m setup an instance and I didn' want him to believed I was implying he hadn't put effort into that
<nicoo>
Ok
<Kakadu>
adrien_oww: I don't get why it doesn't apply to gitlab (which as you said is annoying to setup)
<adrien_oww>
gasche: YES! I never thought a discussion on another medium would completely short-circuit mantis
<adrien_oww>
as for the bug report stuff; what was ocsigen using before?
<adrien_oww>
and was the bug report page _easily_ visible?
thomasga has joined #ocaml
<adrien_oww>
Kakadu: I meant that gitlab is almost impossible to maintain unless you have paid-time to do so
<Kakadu>
ah
<jpdeplaix>
gasche: he wouldn't if ocsigen remained with darcs
<gasche>
did he say so?
avsm has quit [Quit: Leaving.]
<adrien_oww>
but darcs is something very special ...
<jpdeplaix>
but apart from the ocsigen team related peoples, the number of contributions are much higher then before (especially for lwt which it's wildly used standalone)
<adrien_oww>
I consider that an excuse to not get close to a project
<rks`>
jpdeplaix: than*
<adrien_oww>
but lwt was darcs to, right?
<jpdeplaix>
he didn't. But he began contributing only since ocsigen is on github
<rks`>
adrien_oww: too*
<adrien_oww>
:)
<adrien_oww>
that's because I'm sad because my mouse's left button is not working well anymore
<rks`>
I understand.
<jpdeplaix>
(he had a github copy/paste of eliom, …)
avsm has joined #ocaml
<jpdeplaix>
adrien_oww: yes
<adrien_oww>
I've found darcs' slowness really annoying
<jpdeplaix>
slow in which context ?
<adrien_oww>
actually, when I hit the darcsweb of the ocamlforge, I feel sorry for the machine: I'm under the impression it's killing it
<jpdeplaix>
oh yes the web view
<adrien_oww>
the other stuff isn't blazing fast either ;p
ygrek has quit [Ping timeout: 245 seconds]
<adrien_oww>
mouse working well again \o/
<jpdeplaix>
… haskell … No easy troll. Well it wasn't so bad for usual things (except darcsweb and clone with some options)
<adrien_oww>
I used it a bit and within minutes I found it _slow_; maybe I had hit one of these exponential cases but I wasn't doing anything complex, only a few commits and a merge
FreeArtMan has joined #ocaml
FreeArtMon has quit [Ping timeout: 245 seconds]
mdenes has quit [Ping timeout: 246 seconds]
mdenes has joined #ocaml
AltGr has quit [Ping timeout: 272 seconds]
AltGr has joined #ocaml
NoNNaN has quit [Ping timeout: 240 seconds]
Arach has quit [Ping timeout: 240 seconds]
thomasga has quit [Quit: Leaving.]
Arach has joined #ocaml
agnoctone has quit [Ping timeout: 245 seconds]
jonludlam has joined #ocaml
nikki93 has joined #ocaml
FreeArtMon has joined #ocaml
nikki93 has quit [Ping timeout: 260 seconds]
FreeArtMan has quit [Ping timeout: 240 seconds]
mcclurmc has joined #ocaml
Kakadu_ has joined #ocaml
Kakadu has quit [Ping timeout: 245 seconds]
NoNNaN has joined #ocaml
mcclurmc has quit [Ping timeout: 245 seconds]
ollehar1 has joined #ocaml
skchrko_ has quit [Quit: Leaving]
skchrko_ has joined #ocaml
<darklajid>
Hmm.. I fail to bend Str to my will. Seems like regular expressions "don't work" with multiline strings? A simple "foo" doesn't match "bla\nfoo\nbar"?
<flux>
darklajid, I really suggest you to use Pcre instead of the Str module
<darklajid>
Is that part of the 're' module or something completely different again?
<flux>
it's external to ocaml
<flux>
opam install pcre-ocaml
dsheets has quit [Ping timeout: 245 seconds]
thomasga has joined #ocaml
thomasga1 has joined #ocaml
FreeArtMon has quit [Ping timeout: 272 seconds]
<darklajid>
Okay. My secondary issue: All these nice things in opam, how can I access the documentation? ocamlbrowser is my only help so far
<flux>
well, I actually just find the .mli file of the package with cd $(ocamlfind query pcre-ocaml)
<flux>
I think it would be nice if manual pages would be installed as well, not sure if the html documentation already is..
<flux>
and I think the project to have documentation of all the opam packages online is not still complete
<darklajid>
Unfortunately reading the mli (doing that right now) isn't the same as documentation on how to use that thing..
thomasga has quit [Ping timeout: 245 seconds]
<flux>
for many packages it's sufficient
<darklajid>
No string_match or match or .. something remotely familiar in that module, so now I'm trying to find out what a Pcre.regexp is actually good for :)
<flux>
for things like cmdliner, not so much :)
<DantesNewHaircut>
flux, is the order of List.map not undefined?
<darklajid>
Ah. 'exec'. Obviously..
<DantesNewHaircut>
And dependant on the evaluation order of the two arguments to the :: constructor internally?
<flux>
darklajid, for example you could search for 'string -> bool$'
<flux>
and find (by luck) pmatch
kyrylo has joined #ocaml
siddharthv is now known as siddharthv_away
FreeArtMon has joined #ocaml
dant3 has quit [Remote host closed the connection]
avsm has quit [Quit: Leaving.]
<darklajid>
flux: Thanks, but that's .. hrm.. the opposite of nice. Found out how to match (-> bool, thanks) and how to replace/substitute but there's no way that I'll understand the thing when it comes to groups/getting matched parts back out. Since this is a one-off thing I contemplate using Unix.system ("awk") by now :)
dant3 has joined #ocaml
martintrojer has quit [Ping timeout: 252 seconds]
<flux>
darklajid, did you notice the type 'substrings'?
<flux>
darklajid, actually there's function 'extract' what you probably want
<flux>
match Pcre.extract ~pat:"(.*)=(.*)" ~full_match:false "hello=world!" with [| str1; str2 |] -> Printf.printf "%s=%s\n" str1 str2
<flux>
or something
FreeArtMon has quit [Read error: Operation timed out]
FreeArtMan has joined #ocaml
avsm has joined #ocaml
dsheets has joined #ocaml
nikki93 has joined #ocaml
oriba has joined #ocaml
nikki93 has quit [Ping timeout: 252 seconds]
mcclurmc has joined #ocaml
mcclurmc has quit [Ping timeout: 245 seconds]
FreeArtMon has joined #ocaml
avsm has quit [Quit: Leaving.]
thomasga1 has quit [Quit: Leaving.]
ontologiae has joined #ocaml
FreeArtMan has quit [Ping timeout: 245 seconds]
Eyyub has joined #ocaml
martintrojer has joined #ocaml
lostcuaz has joined #ocaml
agnoctone has joined #ocaml
oriba has quit [Quit: oriba]
dant3 has quit [Remote host closed the connection]
hcartym has joined #ocaml
sagotch has joined #ocaml
FreeArtMan has joined #ocaml
<sagotch>
Hi everyone. Is there any chance to parse beginning of line with ocamllex (or, if not, systematically add an EOL token at the begining of returned token list) ?
FreeArtMon has quit [Ping timeout: 260 seconds]
Thooms has quit [Quit: WeeChat 0.3.8]
dant3 has joined #ocaml
yacks has quit [Ping timeout: 264 seconds]
<companion_cube>
sagotch: you can make EOL a token, just return it every time you meet \n
FreeArtMon has joined #ocaml
<sagotch>
Yeah, that's what I do, but I need a false EOL token at the beginning of my file
<sagotch>
I see no way to return EOL before really parsing. I see no way to add a '\n' at the beginning of my lexbuf neither.
yacks has joined #ocaml
FreeArtMan has quit [Ping timeout: 252 seconds]
nikki93 has joined #ocaml
talzeus_ has quit [Remote host closed the connection]
avsm has joined #ocaml
thomasga has joined #ocaml
nikki93 has quit [Ping timeout: 248 seconds]
mcclurmc has joined #ocaml
<Kakadu_>
sagotch: You can write the function which return EOL when is executed 1st time
<Kakadu_>
and returns result of Lexer.token otherwiase
mcclurmc has quit [Read error: Connection reset by peer]
<Kakadu_>
Ideas is that you can manually construct lexbuf
<Kakadu_>
moreover you can create list of tokens and wrap them into function with similar signature as Lexer.token is
<Kakadu_>
It's because OCamlYACC uses some obj.magic hack inside , AFAIR
lostcuaz has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
kaustuv has joined #ocaml
talzeus_ has joined #ocaml
<sagotch>
Hum... I probably will do the "return EOL on first run" trick, but where is the Lexer.token documentation/signature ?
<kaustuv>
Do GADTs have any memory costs? I.e., are there situations where some type information needs to be kept at run time?
NoNNaN has quit [Ping timeout: 240 seconds]
<pippijn>
kaustuv: not more than normal ADTs
bholst has quit [Quit: No Ping reply in 180 seconds.]
rgrinberg has quit [Ping timeout: 246 seconds]
hcartym has quit [Ping timeout: 265 seconds]
zarusky has quit [Ping timeout: 252 seconds]
caligula_ has joined #ocaml
bholst has joined #ocaml
<pippijn>
sagotch: why do you need that?
caligula has quit [Ping timeout: 260 seconds]
gustav has quit [Ping timeout: 252 seconds]
cantstanya has quit [Ping timeout: 264 seconds]
teiresias has quit [Ping timeout: 264 seconds]
fds has quit [Ping timeout: 245 seconds]
ollehar has quit [Remote host closed the connection]
ollehar has joined #ocaml
<kaustuv>
pippijn: thanks. Running with ocaml -dlambda seems to confirm this as well.
_andre has quit [Ping timeout: 252 seconds]
tristero has quit [Ping timeout: 252 seconds]
fds has joined #ocaml
kaustuv has left #ocaml []
jave has quit [Ping timeout: 245 seconds]
<sagotch>
pippijn: Parsing a lightweight markup language, being at begining of line or not does not result in the same behavior
_andre has joined #ocaml
gustav has joined #ocaml
tizoc has quit [Ping timeout: 246 seconds]
teiresias has joined #ocaml
talzeus_ has quit [Read error: Connection reset by peer]
<pippijn>
sagotch: ok, I see
<Kakadu_>
Lexer.token is generated from .mll file, AFAIR
<DantesNewHaircut>
flux, , what's with the map thing though? As far as I know, the order of application in map is undefined and as far as I know in he current ocaml from right to left.
<Kakadu_>
sagotch: ^^
<DantesNewHaircut>
pippijn, is the order of application of functions in List.map not undefined and currently from right to left or am I confused?
shinnya has joined #ocaml
<pippijn>
DantesNewHaircut: it is not undefined
darkf has quit [Quit: Leaving]
FreeArtMan has joined #ocaml
tizoc has joined #ocaml
hcartym has joined #ocaml
jave has joined #ocaml
<pippijn>
DantesNewHaircut: and it is from left to right
<pippijn>
DantesNewHaircut: why do you think it's from right to left?
<hcartym>
kaustuv: GADTs have the same representation internally as ADTs
<sagotch>
Kakadu_: But I see no token function in the resulting .ml file
<DantesNewHaircut>
pippijn, because the evaluation order of subexpressions in OCaml is undefined is it not?
FreeArtMon has quit [Ping timeout: 252 seconds]
<Kakadu_>
I mean someting like `rule token: "\n" { EOL } | .................`
<pippijn>
DantesNewHaircut: yes, but List.map does not create a lot of subexpressions
<pippijn>
it's a function with defined behaviour
<DantesNewHaircut>
Ahh
<DantesNewHaircut>
Where is the behaviour defined then?
<pippijn>
in the documentation
<ggole>
List.map itself has nothing to do with evaluation order
<DantesNewHaircut>
"List.map f [a1; ...; an] applies function f to a1, ..., an, and builds the list [f a1; ...; f an] with the results returned by f. Not tail-recursive."
<DantesNewHaircut>
It doesn't really say anything about application order
<pippijn>
and the function defines its own behaviour
<pippijn>
ok, right, it doesn't say it directly
<ggole>
But yes, you can't rely on evaluation order of arguments (of functions, constructors, records, etc).
<pippijn>
mostly because it shouldn't matter, I guess
<DantesNewHaircut>
pippijn, that it defines its own behaviour contradicts that it is "in the documentation" though.
<DantesNewHaircut>
But let me put it like this, is there any realistic chance that it would be altered at any point?
<pippijn>
no
<DantesNewHaircut>
So code relies on it a lot/
<pippijn>
no
<pippijn>
I've never written code that relies on the execution order within map
zarusky has joined #ocaml
<flux>
dantesnewhaircut, it doesn't need to be defined for it to be useful.
rgrinberg has joined #ocaml
<flux>
dantesnewhaircut, though I'm 100% certain there exists code that assumes it to be evaluated from the first element to the last one
NoNNaN has joined #ocaml
<flux>
if not for anything else then for printing
<companion_cube>
I've been bitten by the execution order from time to time
<companion_cube>
I wouldn't say I rely on it though
<pippijn>
companion_cube: of List.map?
<DantesNewHaircut>
It probably does exist, but I'm pretty sure there also existed code that relied on the left-to-right evaluation order of sub expressions until they changed it
<companion_cube>
hey pippijn o/
<pippijn>
hi
<companion_cube>
pippijn: no, writing my own recursive functions
<companion_cube>
how is it going?
cantstanya has joined #ocaml
ygrek has joined #ocaml
shadynasty has joined #ocaml
<DantesNewHaircut>
companion_cube, you never ask me that.
<DantesNewHaircut>
Is it because I don't have an ij in my name?
DantesNewHaircut is now known as strijkijzer
<flux>
dantesnewhaircut, here's actual side-effectful code involving List.map (from my code): let unregisters = List.map (fun x -> x.e_register_wait wake) xs in
<strijkijzer>
flux, does x.e_register_wait return anything useful?
<strijkijzer>
I like how x / xs is taking over everything.
<flux>
yes, it registers x to be awakened
<strijkijzer>
I see it everywhere in Scheme code as well nowadays in liue of lst and lyst and List
<strijkijzer>
So it's a function that both takes a useful argument, returns a useful argument and has a side effect/
<flux>
so generalized the use case would be registering a list of values by some other means and the registration would always return a function/handle to undo the registration
<flux>
another case involving side-effects: List.map (fun (filename, offset) -> (lazy (rgb24_of_file filename), offset)) samples
<flux>
(it's lazy but could just easily not be)
ocp has joined #ocaml
<flux>
let ids = List.map (fun t -> (t, IdGen.alloc_id t.id_gen)) ts in..
<strijkijzer>
e_register_wait in this case is (unit -> unit) -> unit -> unit right?
<flux>
yes, though I like to parenthesize it (unit -> unit) -> (unit -> unit)
<strijkijzer>
Hmm
<strijkijzer>
well, there's no map_in_order I guess
<strijkijzer>
which arguably should exist for this
<flux>
the order doesn't really matter for any of the cases I had, though
fantasticsid has joined #ocaml
<strijkijzer>
still though, I wouldn't be comfortable relying on the evalution order of map, especially when it's undocumented, it's one of those things which seems like they might change in the future.
shadynasty has quit [Quit: Page closed]
fdagnat has joined #ocaml
gargaml has joined #ocaml
fdagnat has quit [Read error: Connection reset by peer]
fdagnat has joined #ocaml
nikki93 has joined #ocaml
aggelos has joined #ocaml
qerub has joined #ocaml
nikki93 has quit [Ping timeout: 240 seconds]
demonimin has joined #ocaml
nlucaroni has joined #ocaml
dant3 has quit [Remote host closed the connection]
dant3 has joined #ocaml
dant3 has quit [Remote host closed the connection]
travisbrady has joined #ocaml
jao has joined #ocaml
jao has quit [Changing host]
jao has joined #ocaml
lopho has quit [Ping timeout: 276 seconds]
FreeArtMan has quit [Ping timeout: 272 seconds]
<gasche>
strijkijzer: as a library author I learned to always be careful to have the non-surprising evaluation order
<gasche>
(start-to-end for linear structures)
<gasche>
as a library user I learned to avoid rely on it -- but it's fine when the effects commute
zpe has joined #ocaml
<pippijn>
companion_cube: very well :) thanks, how are you?
amirmc has joined #ocaml
<strijkijzer>
gasche, I tend to go with the evaluation that is the most efficient though, I'd make map, iter and map_iter which combines both.
lopho has joined #ocaml
<gasche>
in my experience, in high-level languages evaluation order is fairly independent of efficiency
<strijkijzer>
gasche, well, they switched it from left tor igh tot right to left for a reason though, and I also like which function I use to communicate the intend
bjorkintosh has quit [Ping timeout: 252 seconds]
<strijkijzer>
map communicates that the order should not matter, iter and map_iter communicate that it should.
dant3 has joined #ocaml
qerub has quit [Quit: qerub]
<companion_cube>
pippijn: fine, thank you!
philtor has joined #ocaml
cago1 has left #ocaml []
nikki93 has joined #ocaml
lostcuaz has joined #ocaml
philtor has quit [Ping timeout: 240 seconds]
saml has joined #ocaml
ocp has quit [Ping timeout: 272 seconds]
mika1 has quit [Quit: Leaving.]
nikki93 has quit [Ping timeout: 248 seconds]
ontologiae has quit [Ping timeout: 245 seconds]
dant3 has quit [Remote host closed the connection]
<sagotch>
One more question about ocamllex: can we parse using parameters? This code won't work: rule foo param = parse param { BAR } | ...
tristero has joined #ocaml
<companion_cube>
I guess it's because ocamllex produces a low level automaton, that might not be easy to parametrize
<pippijn>
sagotch: can't do that
<pippijn>
sagotch: what type would you expect param to have?
<sagotch>
a closing closing tag
<pippijn>
no, type
<pippijn>
string?
<sagotch>
yeah
<pippijn>
ocamllex can't do that
<pippijn>
it is theoretically possible
<pippijn>
but then the automaton will be dependent on the parameter
<pippijn>
if you defer automata construction to runtime
dant3 has joined #ocaml
fantasticsid has quit [Remote host closed the connection]
<sagotch>
it could be possible at compilation time since my string is hard-coded, as if there was a ocamllex rule generator
Eyyub has joined #ocaml
<pippijn>
well
<pippijn>
yeah, I see
<pippijn>
you want a macro grammar
<sagotch>
yep
<pippijn>
like menhir
<pippijn>
that's nice
<pippijn>
maybe I'll do that :)
<pippijn>
it's very easy to do
<sagotch>
yes, I was just thinking about writting a preprocessor for ocamllex to allow me to do that...\
dant3 has quit [Ping timeout: 265 seconds]
mal`` has quit [Ping timeout: 272 seconds]
<sagotch>
(if there is no such tool ye)
<sagotch>
yet*
<pippijn>
I don't think there is
<pippijn>
and right now I don't have time to make it
<pippijn>
but maybe next month
mal`` has joined #ocaml
<dsheets>
if i have a module with a type alias in it to a variant, why does ModWithAlias.(fn Variant) give me a warning 40?
<dsheets>
hmm i guess aliases are never followed? how did i miss this?
yacks has quit [Remote host closed the connection]
dant3 has joined #ocaml
<gasche>
dsheets: if you want to re-import constructors, use
<gasche>
type t = OtherMod.t = A | B | C | ...
<gasche>
(you know, the lwt-core-batteries compile failure with Unix 4.01)
<dsheets>
oh? is this a new thing?
<gasche>
no it's very old
<dsheets>
what is this compile failure then?
<dsheets>
i mean, warning 40 is new, i assume the old way was just "you failed" and then i would use the right module scope
dant3_ has joined #ocaml
dant3 has quit [Read error: Connection reset by peer]
<gasche>
I don't understand
q66 has quit [Changing host]
q66 has joined #ocaml
<dsheets>
gasche, what was the lwt-core-batteries compile failure with Unix 4.01?
<rks`>
there was a new constructor in Unix.open_flags
<dsheets>
(re the newness, this scope ambiguity support is new, i thought)
<gasche>
my point was that if you have module B = struct type t = A.t = Foo | Bar | Baz end, then B.(Foo) will work (and not raise a scope ambiguity warning)
<dsheets>
ok, i will do this now
<dsheets>
thanks!
<gasche>
while (Foo) alone (or B.(Foo) in the version with just (type t = A.t)) will fail (with older OCaml versions) or raise the ambiguity warning (in 4.01)
<gasche>
(the ambiguity warning is there because people could not decide whether accessing a variant that is not in scope is totally evil and should be banned by an error, or actually a good idea)
<pippijn>
(I'm just half following the conversation)
<dsheets>
i've been using @40 more recently
Yoric has quit [Ping timeout: 240 seconds]
dant3_ has quit [Ping timeout: 245 seconds]
<gasche>
pippijn: I personally doubt this will ever change, since the behavior is allowed in a released version of OCaml
<gasche>
it could be made @ (turned into an error) by default at best
avsm has quit [Quit: Leaving.]
<gasche>
there were people for and against allowing this behavior, with fair arguments on both sides, it's time to move on
mcclurmc has joined #ocaml
avsm has joined #ocaml
Eyyub has quit [Ping timeout: 245 seconds]
ollehar has quit [Ping timeout: 272 seconds]
ollehar has joined #ocaml
Eyyub has joined #ocaml
Eyyub has quit [Ping timeout: 252 seconds]
Eyyub has joined #ocaml
jwatzman|work has joined #ocaml
cesar_ has joined #ocaml
cesar_ is now known as Guest41899
Yoric has joined #ocaml
ollehar has quit [Ping timeout: 272 seconds]
mcclurmc has quit [Ping timeout: 272 seconds]
manizzle has quit [Ping timeout: 252 seconds]
mcclurmc has joined #ocaml
avsm has quit [Quit: Leaving.]
avsm has joined #ocaml
pminten has joined #ocaml
Yoric has quit [Ping timeout: 264 seconds]
Kakadu_ has quit [Quit: Page closed]
jonludlam has quit [Remote host closed the connection]
sagotch has quit [Quit: Page closed]
agnoctone has quit [Quit: Page closed]
avsm has quit [Quit: Leaving.]
Guest41899 has quit [Remote host closed the connection]
shinnya has quit [Ping timeout: 260 seconds]
amirmc has quit [Quit: Leaving.]
nikki93 has joined #ocaml
nikki93 has quit [Ping timeout: 248 seconds]
martintrojer has quit [Ping timeout: 252 seconds]
thomasga has quit [Quit: Leaving.]
malvarez has joined #ocaml
Kakadu has joined #ocaml
AltGr has left #ocaml []
pminten has quit [Remote host closed the connection]
qerub has joined #ocaml
boogie has joined #ocaml
amirmc has joined #ocaml
manizzle has joined #ocaml
fdagnat has quit [Ping timeout: 240 seconds]
BullSherd has joined #ocaml
BullSherd has left #ocaml []
Eyyub has quit [Read error: Operation timed out]
jwatzman|work has quit [Quit: jwatzman|work]
amirmc has quit [Quit: Leaving.]
Eyyub has joined #ocaml
mcclurmc has quit [Remote host closed the connection]
thomasga has joined #ocaml
Yoric has joined #ocaml
mcclurmc has joined #ocaml
malvarez has quit [Ping timeout: 260 seconds]
mcclurmc has quit [Remote host closed the connection]
bjorkintosh has joined #ocaml
nikki93 has joined #ocaml
Yoric has quit [Ping timeout: 245 seconds]
mcclurmc has joined #ocaml
nikki93 has quit [Ping timeout: 252 seconds]
malvarez has joined #ocaml
mye has joined #ocaml
mcclurmc has quit [Remote host closed the connection]
nikki93 has joined #ocaml
thomasga has quit [Ping timeout: 252 seconds]
zpe has quit [Remote host closed the connection]
zpe has joined #ocaml
dsheets has quit [Read error: Operation timed out]
shadynasty has joined #ocaml
zpe has quit [Ping timeout: 265 seconds]
<j0sh>
how does pgocaml manage to pass its monadic return values (eg, 'a t) into non-monadic functions like List ('a list t)?
ggole has quit []
dant3 has joined #ocaml
<j0sh>
without any binding/unwrapping
thomasga has joined #ocaml
ulfdoz has joined #ocaml
Eyyub has quit [Ping timeout: 264 seconds]
Eyyub has joined #ocaml
Eyyub has quit [Client Quit]
Eyyub has joined #ocaml
thomasga has quit [Quit: Leaving.]
Yoric has joined #ocaml
dant3 has quit [Remote host closed the connection]
dsheets has joined #ocaml
FreeArtMan has joined #ocaml
ygrek has quit [Ping timeout: 272 seconds]
FreeArtMan has quit [Quit: main.lv]
mw1001 has joined #ocaml
mw1001 has quit [Quit: Ex-Chat]
<smondet>
j0sh: not sure I understand your question, you mean how PGOCaml works in non-monadic form with posix threading?
dsheets has quit [Quit: Leaving]
dsheets has joined #ocaml
<j0sh>
smondet: well i can pass in what appears to be a pgocaml return value with a monadic type into non-monadic functions like List.iter
<j0sh>
of course this doesn't work when i instantiate pgocaml with an actual monad like Lwt
<j0sh>
so i'm not sure what's different between the default/generic pgocaml module and one using lwt
<smondet>
when you take the non-Lwt module, you have type 'a t = 'a so you can use List.iter and so on
<smondet>
with the lwt version you can use Lwt_list equivalents
<smondet>
(there are functions Lwt_list.iter_s, iter_p, map_...)
<smondet>
if you want to remain "abstract" over the monad
<smondet>
you can use List.fold to iterate for example
contempt has quit [Ping timeout: 240 seconds]
<smondet>
List.fold ~init:(return ()) ~f:(fun prev v -> prev >>= fun () -> do_stuff; return ()) the_list
<j0sh>
maybe i'm not completely understanding the implications of the 'a t = 'a type
dant3 has joined #ocaml
<j0sh>
does that denote a function, eg ('a t -> 'a) ?
<smondet>
no
zpe has joined #ocaml
<smondet>
it's a trick.... difficult to explain :)
ollehar1 has quit [Ping timeout: 245 seconds]
<smondet>
when you look at the module PGOCaml (the non-generic / non-lwt one)
<smondet>
you see the type 'a monad = 'a
ollehar has joined #ocaml
<smondet>
All the functions that return 'something monad' in the functor "become" functions that return 'something'
<smondet>
so you don't have to deal with the monad at all
<j0sh>
ah
contempt has joined #ocaml
<j0sh>
so i guess that's the trick
<j0sh>
makes sense, thanks
zpe has quit [Ping timeout: 272 seconds]
<j0sh>
so in the lwt version, it would be 'a t = 'a Lwt.t, okay
contempt has quit [Ping timeout: 245 seconds]
contempt has joined #ocaml
ollehar has quit [Ping timeout: 245 seconds]
ollehar has joined #ocaml
<smondet>
j0sh: yes, to be precise type 'a monad = 'a Lwt.t ('a PGOCaml.t is the database handle)
ollehar has quit [Ping timeout: 245 seconds]
ollehar has joined #ocaml
<pippijn>
companion_cube: I got lost after all
<pippijn>
for a moment
<companion_cube>
aww
<companion_cube>
are you alive?
<pippijn>
yep
mocrunsthecity has joined #ocaml
<pippijn>
and found my way
dant3 has quit [Remote host closed the connection]
dant3 has joined #ocaml
<companion_cube>
time to code now :p
mocrunsthecity has quit [Remote host closed the connection]
dant3 has quit [Remote host closed the connection]
<pippijn>
\o/
mocrunsthecity has joined #ocaml
<companion_cube>
how could I live without the |> operator??
<companion_cube>
let depth t = Seq.subterms_depth t |> Sequence.map snd |> Sequence.fold max 0
<adrien>
you were dreamining of making your very special operator instead
<adrien>
|) probably (it's closer to a wheel)
<adrien>
brup
<adrien>
burp*
S11001001 has joined #ocaml
<strijkijzer>
I'm kind of surprised that Haskell didn't hav eit, I defined $> for that purpose.
ollehar has quit [Ping timeout: 245 seconds]
<strijkijzer>
.> being reversed composition to complete it.
<companion_cube>
adrien: you evil propagandist
S11001001 has quit [Changing host]
S11001001 has joined #ocaml
<strijkijzer>
Then again, I'm also surprised that OCaml does not seem to have composition as a primitive library function
<companion_cube>
note that I still use my own iterator type there :p
<companion_cube>
yes, you should use batteries :>
<strijkijzer>
I feel that in general function composition cannonically goes in the wrong way.
ollehar has joined #ocaml
<strijkijzer>
f . g with g composed onto f rather than in reverse makes more sense because we read from left to right
<S11001001>
strijkijzer: well it's too late to make it that way
<strijkijzer>
S11001001, that is what I never really agree with when designing a new language, maybe if the language already exists but as long as you make a language that is new like say you are Robert Milner and decide to invent ML, might as well erase any past mistakes since people are going to have to learn your language anyway.
<S11001001>
strijkijzer: that doesn't happen, though. No one reinvents absolutely everything
<S11001001>
strijkijzer: anyway, similar readability arguments can be made *in favor* of the standard order.
<strijkijzer>
Well, you can use things that aren't mistakes of course.
<strijkijzer>
S11001001, hmm, you think so?
<S11001001>
strijkijzer: absolutely
<strijkijzer>
I've never seen someone defend the standard order on anything other than initeria, what's an advantage aside inertia?
<strijkijzer>
Truth be told, if I designed a language I would make numbers go in the opposite direction... one hundred and 5 would be 501
<S11001001>
strijkijzer: discourages operational thinking, looks like its elided version f (g x)
<strijkijzer>
I get the latter, not the former though
<strijkijzer>
What's wrong with operational thinking?
<S11001001>
strijkijzer: that we have more powerful tools
<strijkijzer>
than functional composition?
<S11001001>
than operational thinking
<strijkijzer>
Such as?
<companion_cube>
equational reasoning, I guess
<strijkijzer>
Hmm
<strijkijzer>
I personally don't really but that standard functional programming is "declarative", you still define the steps a program is to take, it just doesn't contain side effects.
<strijkijzer>
You don't really define "what a problem is" given that you can do things like let a x = a (1 + x);;
<strijkijzer>
No idea what that is but the computer obendiently executes your instructions for you
<S11001001>
you're free to continue with an exclusively operational approach if you like
<strijkijzer>
And reversing functional composition leads one to think of a problem like that?
<S11001001>
but for me, no thanks
ollehar has quit [Ping timeout: 245 seconds]
<strijkijzer>
Ahh, Edsger.
_andre has quit [Quit: leaving]
ollehar has joined #ocaml
<strijkijzer>
But how does the order of the compositional operator leads one to think about programs posulatively?
<S11001001>
it's more that the justification of the other order sounds operational, that is, "because the RHS of compose 'happens first'".
<S11001001>
because the standard compose is in the "wrong" order, it puts up a roadblock here
<strijkijzer>
Wel, the "order" here is not necessarily one of time or steps of execution
qerub has quit [Quit: qerub]
<strijkijzer>
But in the case of function types like int -> int, this principle is seemingly maintained of keeping order left to right.
qerub has joined #ocaml
<strijkijzer>
Which leads to compose : ('b -> c') -> ('a -> 'b) -> ('a -> 'c)
mcclurmc has joined #ocaml
<strijkijzer>
One already sees the some-what counter intuitive nature of this order ('a -> 'b) -> ('b -> 'c) -> ('a -> 'c) would appeal more to straightforwardness
<companion_cube>
so you have an operator %> that composes from left to right
<strijkijzer>
In Haskell I have (.>) :: (a -> b) -> (b -> c) -> (a -> c) yes
<strijkijzer>
And ($>) :: a -> (a -> b) -> b
<strijkijzer>
Which is basically (|>) : 'a -> ('a -> 'b) -> 'b in OCaml.
oriba has joined #ocaml
fdagnat has joined #ocaml
Eyyub has quit [Ping timeout: 248 seconds]
malvarez has quit [Ping timeout: 252 seconds]
zpe has joined #ocaml
Eyyub has joined #ocaml
ollehar has quit [Ping timeout: 245 seconds]
ollehar has joined #ocaml
<j0sh>
do let _ = ... blocks get evaluated, or tossed by the compiler?
<nlucaroni>
they will get evaluated
<j0sh>
just spent an hour debugging that... it doesn't evaluate unless the let is bound to a variable and actually used
<nlucaroni>
maybe if the result is lazy
<j0sh>
might it have something to do with using lwt?
<nlucaroni>
yeah, that could be
<def-lkb>
something must be wrong in your setup, let _ = are evaluated.
<j0sh>
i thought Lwt.bind or >>= made it non-lazy
malvarez has joined #ocaml
<def-lkb>
it's not lazy it's… delayed
<nlucaroni>
well, it's not lazy, it's defered.
jdoles has quit [Read error: Connection reset by peer]