flux changed the topic of #ocaml to: Discussions about the OCaml programming language | http://caml.inria.fr/ | OCaml 4.00.1 http://bit.ly/UHeZyT | http://www.ocaml.org | Public logs at http://tunes.org/~nef/logs/ocaml/
<thizanne> because you and adrien does not seem to be trustable enough
<mk270> i WANT it to get outdated quickly
ousado_ is now known as ousado
<mk270> because that means that ocaml developers don't have to relearn all this pointless shit every three months
<wmeyer```> I don't mk270 that this needs to be signed by anybody blood, but i think community would welcome you warmly
<rks_> I think there is a misunderstanding here.
ousado has quit [Changing host]
ousado has joined #ocaml
<mk270> sorry, the blood thing dates from when i ran IT at a games company, and insisted that changes to people's userid be signed off in the blood of their line manager
<wmeyer```> mk270: i also don't understand to be honest, feel free to make the page, we getting in ocaml world the tools more stable :-)
<mk270> made a reasonable effort to get this encoded in the company's terms of employment
<wmeyer```> well community <> company, let's say up-front
<mk270> yes, obviously
<wmeyer```> you don't have to be worried :p
<mk270> ok, so what does a _tags file that imports ocaml-expat look like?
<mk270> true: package(ocaml-expat)
<mk270> ?
<wmeyer```> mk270: yes, as rks_ advised this is probably option that would work
<mk270> Warning: tag "package" does not expect a parameter, but is used with parameter "ocaml-expat"
<rks_> mk270: do you run
<wmeyer```> you can also "ocamlbuild -tags 'true: package(ocaml-expat)'"
<rks_> ocamlbuild -use-ocamlfind yourtarget ?
<wmeyer```> but this get's a bit tiring
<rks_> (the "-use-ocamlfind" is important)
<mk270> rks_: not every time. sorry, thank you
<mk270> thanks
<mk270> though
<mk270> ocamlfind: Package `ocaml-expat' not found
<mk270> i did opam install ocaml-expat
<wmeyer```> mk270: what does "ocamlfind list" tell you?
<mk270> thanks
<mk270> it's really called something slightly different
<mk270> fair enough
<wmeyer```> rks_: the plan was to make it default btw. but of course it will take time for them to develop
<mk270> awesome. it works.
<rks_> wmeyer```: speaking about ocp-build?
<rks_> guess so
<rks_> but if it goes as it did for opam, they might achieve it
<wmeyer```> rks_: speaking about -use-ocamlfind, and it's behavior when the options are not specified
<rks_> oh :'
tane has quit [Quit: Verlassend]
darkf has joined #ocaml
doc_who has joined #ocaml
<mk270> wmeyer``` and rks_: thank you both
<wmeyer```> rks_: ocp-build seems to be interestting
<wmeyer```> mk270: you are welcome
<mk270> i hope i find time to write this up
<rks_> mk270: you're welcome
eikke has quit [Ping timeout: 245 seconds]
* wmeyer``` has some minor headache at the moment
<wmeyer```> mk270: please try to write it up, thanks
<wmeyer```> it's not the first time some people say it
eikke has joined #ocaml
<mk270> wmeyer```: starting at https://gist.github.com/mk270/5408855
pkrnj has joined #ocaml
smerz_ has quit [Ping timeout: 245 seconds]
<wmeyer```> mk270: good start, thank you
thomasga has quit [Quit: Leaving.]
<mk270> wmeyer```: i have now updated it
<mk270> with all the stuff you guys said
<wmeyer```> you can say just: "make world.opt" instead of "make bootstrap opt"
<wmeyer```> also you can download stuff with wget btw.
eikke has quit [Ping timeout: 245 seconds]
<wmeyer```> (that's essentially what ocamlbrew does)
<wmeyer```> otherwise allready looks useful
<rks_> « The latter command appears to download and install a fresh OCaml compiler(!) »
<rks_> you can remove the "appears"
<rks_> (and it not only download and install but also build a fresh ocaml compiler)
<wmeyer```> mk270: and I think I'd add _tags in the root
<wmeyer```> only
<mk270> hmm
<mk270> it'd be easier to have a repo rather than a gist
<mk270> with just a single README.md in it
<mk270> ok
* wmeyer``` being anxious about tomorrow to get up
<mk270> i have to flee the country in a few hours
<wmeyer```> it's excellent starting point for most people: I'd hyper link stuff to it too, rather giving just this raw guide
<mk270> gimme just two more minutes to get this sorted
<rks_> mk270: it would be better to put that in the appropriate place on ocaml.org (which you already know how to contribute to)
<mk270> now to push
<mk270> the gist into it somehow
<rks_> I'll let you define "appropriate place" :]
<wmeyer```> mk270: actually what rks_ says whas the next thing i meant to recommend
<mk270> ok it is there and it renders
<mk270> rks_: no
<mk270> it can go on ocaml.org when it's a bit more polished
<mk270> the ocaml.org ppl take days to answer pull requests
<rks_> :)
<mk270> whereas i am looking on github right now for your userids to add you
<rks_> they probably do yes
<rks_> :D
<mk270> wmeyer```: you on github?
<rks_> you (probably) won't find it mk270
<wmeyer```> actually my github id is danmey
<mk270> ah yes
<wmeyer```> (to some extent i use this id)
<mk270> added
<wmeyer```> it's a bit sad that ocaml.org is slow at fetching changes
ollehar has quit [Ping timeout: 256 seconds]
<mk270> they don't get the idea that you merge pull requests first, and fix them immediately afterwards, rather than asking the contributor to do more work
<rks_> well mk270
<wmeyer```> yeah, but it makes them happier, because they can punish you :D
<mk270> they really are not in a position to punish anyone
<rks_> not everybody has the time to fix the "contributors" mistakes
<wmeyer```> mk270: no; please received this gentle joke. The care also about the quality of the contributions, right?
<mk270> rks_ that's not an argument against a pull request to a documnetation site which creates a *net* increase in value of the docs
<rks_> anyway mk270, wmeyer```
<rks_> looking at their github repo, I can see that the last few pull requests have been answered in less that a day
<mk270> then they have improved
<rks_> (except for your pull request mk270, which you submitted 2 hours ago, when it's already the middle of the night in most of the places on the planet)
<rks_> so well, I guess they're doing ok :p
<rks_> anyway
<rks_> mk270: have fun using ocaml
<rks_> everyone: good night
<wmeyer```> rks_: good night!
<mk270> rks_ cheers
<mk270> night all
<mk270> thanks for the help both
<wmeyer```> mk270: yep. Have good night
breakds_ has quit [Ping timeout: 276 seconds]
jbrown has quit [Ping timeout: 240 seconds]
pkrnj has quit [Quit: Computer has gone to sleep.]
Neros has quit [Ping timeout: 276 seconds]
madroach has quit [Ping timeout: 248 seconds]
madroach has joined #ocaml
<ousado> wmeyer```: I decided to work on some 'complete noobs guide to type-driven code generation in ocaml' until I know enough to make a sufficiently informed decision whether to use extension points and/or Fan and/or camlp4/5
derek_c has joined #ocaml
derek_c_ has joined #ocaml
derek_c_ has quit [Client Quit]
derek_c_ has joined #ocaml
pkrnj has joined #ocaml
yacks has joined #ocaml
derek_c has quit [Ping timeout: 264 seconds]
<wmeyer```> ousado: nice
<wmeyer```> ousado: i'd skip camlp4/p5 but if you decide to do both extension_points and Fan, then fair comparion would be great
<ousado> wmeyer```: the most complete example for extension points I could find is your omonad
<wmeyer```> keep in mind that it uses just -ppx, but maybe not new syntax in the parse tree
<ousado> wmeyer```: re skipping, yes, I thought about that too, but I have to face the facts, and camlp4 has the great advantage of being documented at all
<ousado> and re new syntax, also yes, I'm not sure it'll be a requirement for me personally, though
<ousado> but for possible future demands I'll take it into account
<ousado> I looked at mirage/cow for instance
derek_c_ has quit [Ping timeout: 248 seconds]
derek_c has joined #ocaml
<wmeyer```> ousado: I think attributes on types are very lightweight, and it would just much easier to support it, than using p4
<ousado> wmeyer```: I'm simply afraid that I won't understand the ocamlers metaprogramming mindset without looking at camlp4
<ousado> I'm not planning to go into great detail, and if it has too much overhead I'll drop it anyway
talzeus_ has joined #ocaml
<ousado> since this is manly an evaluation which of these, if any, can match or beat haxe in terms of flexibility and accessibility
<wmeyer```> ousado: yep, camlp4 is a great start.
<wmeyer```> to understand how to generate programs
<wmeyer```> ok time for me
<ousado> wmeyer```: good night
<wmeyer```> ousado: good night
oriba has quit [Quit: oriba]
derek_c has quit [Quit: leaving]
UncleVasya has joined #ocaml
darkf_ has joined #ocaml
darkf has quit [Disconnected by services]
darkf_ is now known as darkf
lenstr has quit [Ping timeout: 240 seconds]
LeNsTR has joined #ocaml
Trollkastel has quit [Quit: Brain.sys has encountered a problem and needs to close. We are sorry for the inconvenience.]
Trollkastel has joined #ocaml
lopex has quit [Read error: Operation timed out]
IbnFirnas has quit [Read error: Operation timed out]
lopex has joined #ocaml
jpdeplaix has joined #ocaml
jpdeplaix` has quit [Ping timeout: 276 seconds]
Kakadu has joined #ocaml
beckerb has joined #ocaml
talzeus_ has quit [Quit: where is the love...]
talzeus_ has joined #ocaml
ggole has joined #ocaml
Arsenik has joined #ocaml
UncleVasya has quit [Quit: UncleVasya]
yacks has quit [Read error: Operation timed out]
ulfdoz has joined #ocaml
karswell has joined #ocaml
Trollkastel is now known as lambdadelta
weie has joined #ocaml
yacks has joined #ocaml
Myk267 has joined #ocaml
zpe has joined #ocaml
lambdadelta has quit [Quit: Brain.sys has encountered a problem and needs to close. We are sorry for the inconvenience.]
Trollkastel has joined #ocaml
zpe has quit [Ping timeout: 255 seconds]
ulfdoz has quit [Ping timeout: 256 seconds]
anderse has joined #ocaml
talzeus_ has quit [Read error: Operation timed out]
talzeus_ has joined #ocaml
awm22 has quit [Quit: Leaving.]
Myk267 has left #ocaml []
pkrnj has quit [Quit: Textual IRC Client: www.textualapp.com]
anderse has quit [Quit: anderse]
zpe has joined #ocaml
LeNsTR has quit [Changing host]
LeNsTR has joined #ocaml
Arsenik has quit [Remote host closed the connection]
hkBst has joined #ocaml
hkBst has quit [Changing host]
hkBst has joined #ocaml
zpe has quit [Ping timeout: 245 seconds]
Snark has joined #ocaml
djcoin has joined #ocaml
ttamttam has joined #ocaml
djcoin has quit [Quit: WeeChat 0.3.9.2]
zpe has joined #ocaml
djcoin has joined #ocaml
zpe has quit [Remote host closed the connection]
zpe has joined #ocaml
cago has joined #ocaml
areece has quit [Quit: No Ping reply in 180 seconds.]
areece has joined #ocaml
Fnar has quit [Quit: Client exiting]
awm22 has joined #ocaml
Neros has joined #ocaml
mika1 has joined #ocaml
frogfoodeater has quit [Ping timeout: 256 seconds]
<orbitz> Is there a suggested tutorial/doc on building C interfaces in Ocaml?
<companion_cube> http://www.linux-nantes.org/~fmonnier/ocaml/ocaml-wrapping-c.php take a look at this, I'd guess
<pippijn> yeah, that one
<pippijn> and otherwise, the ocaml reference
<pippijn> manual
<orbitz> great thanks
<adrien_oww> I typically use both
* orbitz will embark on first attempt at wrapping a C API
<adrien_oww> use the fmonnier page as a starting point and the reference for more details
<adrien_oww> orbitz: I'm curious: which one?
<pippijn> Wt
<orbitz> adrien_oww: I'm going to start just with learning on a simple library, but my goal is to find an SSH implementation I can wrap that I can integerate with Async
<adrien_oww> ok, good luck
<orbitz> The only ocaml ssh library I could find is ocaml-ssh, which is not released code and seems quite stale
<orbitz> adrien_oww: I'm sure I'll need the luck.
<adrien_oww> btw, Gc.compact () is a good way to trigger memory corruption bugs
<orbitz> Hah
<adrien_oww> don't hesitate to call it by hand
<flux> if only it wasn't so hard to write properly working ocaml bindings
<companion_cube> :D
<flux> actually someone(TM) could do a new static analyzer for that purpose, based on llvm
<companion_cube> Gc.destroy_my_C_wrapper
<orbitz> My other possibility, which I'm not sure if it's horrific or not, is to write a very tiny ssh proxy app in C and then talk to that via pipes
<adrien_oww> flux: sapphire :P
<pippijn> flux: that needs an ocaml parser, too
<companion_cube> orbitz: isn't that ssh itself?
<flux> adrien_oww, yes, it exists, but isn't maintained afaik?
<adrien_oww> yup
<pippijn> flux: so you can verify the ocaml side
<flux> pippijn, I hope we have that already..
<orbitz> companion_cube: Yes, but ssh is 1 process per conenction, I want to handle many more
<companion_cube> oh.
<orbitz> unless I'm mistaken about SSH
<companion_cube> ok then
<adrien_oww> I have the source and tried building it but it needs some changes to a parser or to some cmalp4 code and I don't know whtat
<adrien_oww> that*
<orbitz> I'm hoping to use this to orchestarte some machines
<flux> actually a debugging tool idea comes to my mind
<adrien_oww> actually I had asked for help on the caml-list but got no answer
<flux> a perverted Gc.compact that tries to move memory around as much as legally possible :)
<orbitz> The ssh multiplexer app is nice since that integrates with the rest of unix pretty well
<orbitz> Hrm, how bad of an idea does that sound?
<adrien_oww> but at least, it's possible to look at what it does and port it
<companion_cube> orbitz: sounds nice
<adrien_oww> flux: you can probably achieve that by allocating as much as possible in a way that fragments memory
<orbitz> And I get to write C, wheee :)
<companion_cube> out of curiosity, do you have an opinion on binary Sexpr ?
<adrien_oww> what is it?
<pippijn> companion_cube: sexpr with netstrings?
<adrien_oww> orbitz: having the ssh code in another app can be fairly good imho
<companion_cube> it's a way of representing Sexpr by prefixing with length, directly in binary
<orbitz> adrien_oww: in this case I'm thinking it could be, simplicity, an app all in C that just multiplexses ssh connections, of course that means it's likely to blow up, but at least i twon't bring down your ocaml app in fun and interestin ways
<orbitz> tahnks for the feedback!
<companion_cube> keep us informed :p
hkBst has quit [Ping timeout: 245 seconds]
thomasga has joined #ocaml
mcclurmc has joined #ocaml
hkBst has joined #ocaml
hkBst has quit [Changing host]
hkBst has joined #ocaml
ocp has joined #ocaml
frogfoodeater has joined #ocaml
ontologiae has joined #ocaml
hkBst has quit [Read error: Connection reset by peer]
hkBst has joined #ocaml
hkBst has quit [Changing host]
hkBst has joined #ocaml
frogfoodeater has quit [Ping timeout: 264 seconds]
awm22 has quit [Ping timeout: 256 seconds]
Yoric has joined #ocaml
awm22 has joined #ocaml
eikke has joined #ocaml
ggole has quit [Ping timeout: 256 seconds]
cdidd has quit [Ping timeout: 256 seconds]
malo has joined #ocaml
ocp has quit [Ping timeout: 245 seconds]
ollehar has joined #ocaml
ggole has joined #ocaml
def-lkb has quit [Ping timeout: 248 seconds]
jbrown has joined #ocaml
def-lkb has joined #ocaml
awm22 has quit [Quit: Leaving.]
def-lkb has quit [Ping timeout: 264 seconds]
awm22 has joined #ocaml
awm22 has quit [Client Quit]
def-lkb has joined #ocaml
awm22 has joined #ocaml
asmanur has quit [Ping timeout: 264 seconds]
asmanur has joined #ocaml
dsheets has joined #ocaml
dsheets has quit [Read error: Operation timed out]
dsheets has joined #ocaml
<pippijn> too bad the syntax highlighting doesn't like my syntax
eikke has quit [Ping timeout: 264 seconds]
SuperNoeMan has quit [Ping timeout: 248 seconds]
SuperNoeMan has joined #ocaml
Fnar has joined #ocaml
dsheets has quit [Ping timeout: 245 seconds]
breakds has joined #ocaml
frogfoodeater has joined #ocaml
Trollkastel has quit [Read error: Connection reset by peer]
fraggle_ has quit [Ping timeout: 245 seconds]
chambart has joined #ocaml
eikke has joined #ocaml
chambart has quit [Read error: Operation timed out]
Neros_ has joined #ocaml
hkBst has quit [Ping timeout: 245 seconds]
Neros has quit [Ping timeout: 245 seconds]
_andre has joined #ocaml
hkBst has joined #ocaml
hkBst has quit [Changing host]
hkBst has joined #ocaml
chambart has joined #ocaml
hkBst has quit [Ping timeout: 245 seconds]
hkBst has joined #ocaml
hkBst has quit [Changing host]
hkBst has joined #ocaml
q66 has joined #ocaml
hkBst has quit [Remote host closed the connection]
hkBst has joined #ocaml
ocp has joined #ocaml
dsheets has joined #ocaml
<fasta> Where do you draw the line between writing something in OCaml and e.g. in plain bash or sh?
<darkf> fasta: when it's not a one-off script?
<adrien_oww> when you need data structures
<fasta> darkf: I cache all the scripts that I write.
<fasta> adrien_oww: yes, I think that's it for me too.
<fasta> adrien_oww: but lots of shell scripts don't need those.
chambart has quit [Ping timeout: 256 seconds]
<adrien_oww> and you don't need something terribly reliable
<fasta> For example: if you want to set-intersection you can just implement that efficiently too.
<orbitz> I use bash if most of the script is just composing other applications without doing anything else itself
<adrien_oww> the issue with shell script is rarely performance
<adrien_oww> almost always reliability
<orbitz> indeed
<adrien_oww> once you get something reliable, you might think about performance
<fasta> I think I would implement it in OCaml if the bits it would be operating on came from the outside world.
<adrien_oww> but chances are you won't get something very advanced and reliable
<orbitz> I enjoy writing interesting shell scripts, but mostly because It's all about finding fun ways to compose apps, once I need to use any datastructure it's jsut painful
<fasta> I think most scripts don't handle file names with newlines in them for example.
<orbitz> you have to be extra carefu for that, yes
<fasta> But otherwise I find shell scripts very easy to write.
<flux> next ubuntu should rename /home to /\nhome and then we'd get the problems sorted once and for all!
<flux> kinda like windows did with C:\Program Files
<flux> it seems to have worked great
<fasta> flux: yeah, and its database tables 'DROP * FROM foo;'
<fasta> It would also be nice if errors would result in a sound playing like "HAHA" (the kid from the Simpsons).
<fasta> That would be a nice April 1st joke to do.
gnuvince has quit [Ping timeout: 245 seconds]
<fasta> I also don't really see the whole reliability angle. Are you talking about large pipes where when an error occurs, you don't know which process generated the error?
UncleVasya has joined #ocaml
<fasta> E.g. commanda|commandb|c|d|e
<flux> I think mostly the problem is the fragility
<orbitz> yes, i usually use bash scripts fo things that will alway ssucceed, or if they fail it can just exit with set -x
<flux> if something unexpected happens, the results can be unexpected as well :)
<fasta> orbitz: how do you mean with -x?
<flux> for example a script assumes $foo is a prefix, well it's actually empty, next we rm -rf "$foo/*"
<fasta> orbitz: I know what -x does.
<flux> actually I didn't mean empty but rather it's never set
<orbitz> fasta: in the shell you do set -x at beginning
<fasta> orbitz: but collecting output and only showing it when it fails whould be useful.
<fasta> orbitz: set -x unconditionally outputs everything.
<orbitz> ohh shit
<orbitz> i mean -e
<orbitz> set -e
<fasta> orbitz: set -e doesn't do that either ;)
<fasta> orbitz: set -e only stops the script when anything fails.
<orbitz> set -e termiantes if any application you call returns !0
<orbitz> right
<orbitz> which is waht I want in my shell scripts
<fasta> It's equivalent to putting && everywhere.
<fasta> tlc also has implicit && by default.
<fasta> tcl
<orbitz> fasta: yes, which is what I want
<fasta> Tlc is rapper, I think.
<orbitz> fasta: it's a group of rappers
<orbitz> one of which is dead
<orbitz> RIP
ollehar has quit [Ping timeout: 252 seconds]
hkBst has quit [Ping timeout: 248 seconds]
<ggole> Oh god, bash scripts.
* ggole shivers
hkBst_ has joined #ocaml
mort___ has joined #ocaml
<fasta> ggole: A sh script has access to pretty much every interesting application and it runs on pretty much every platform, there is no need for a build system, no drama over compilers. A pure OCaml solution would involve setting up a build system, thinking about which libraries to import, more work to setup a command line interface (there is no docopts for OCaml), etc.
<gasche> I think if you use your stuff purely as a script, "ocaml foo.ml" with '#use "topfind"' in the source can do a reasonable job
smondet has joined #ocaml
thelema_ has joined #ocaml
<fasta> I consider it for example to be a disadvantage that the OCaml compiler cannot be bootstrapped from a tiny bit of understandably code.
mort___ has left #ocaml []
<fasta> If I would be running a bank, I would probably keep OCaml out only for that reason, despire Jane St. Capital existing.
<fasta> despite*
<ggole> fasta: my problem with bash scripts is that bash is as flaky as hell
<ggole> Random spaces or newlines can screw you
<ggole> The various workarounds are clumsy and inconsistent
thelema has quit [Ping timeout: 248 seconds]
<ggole> Imho the only sane use of bash code is to configure bash
<fasta> ggole: so, in what do you write your operating system deployment code?
<ggole> Python
<fasta> Python is often not present on embedded Linux, though.
<ggole> In theory it isn't as portable as bash: in practice it is more portable, since it also runs on windows
<fasta> Yeah, but Windows is dying.
<ggole> Yeah
<ggole> But that'll take a while
<ggole> Still huge in enterprise
<fasta> ggole: I happen to be writing a slightly less trivial script in Python right now ;)
<fasta> ggole: how can one turn a string into a list in Python without using the full power of eval?
<ggole> .split? Depends on what semantics you want.
<fasta> ggole: I want the semantics to be "exception or same result as if eval had seen it".
<fasta> Without actually calling functions, of course.
<ggole> O_o
<fasta> So, e.g. ["a","b"] could be in some file.
<ggole> Sounds like you need eval: but you almost never really need eval.
<fasta> ggole: no, I only want the constant parsing part.
<ggole> Hmm, this exhausts my limited knowledge of Python.
<ggole> I know there are sandboxes to prevent bad things happening form parsing Python code
<ggole> But I don't have any experience with any of them.
<ggole> Find a real Python guy, I guess.
chambart has joined #ocaml
<ggole> Or maybe arrange for a different format to be acceptable: JSON, perhaps
gnuvince has joined #ocaml
fraggle_ has joined #ocaml
<gasche> iPython looks rather nice as an extension of a programming language to handle the shell aspects better
<ggole> Is that the library that maps common commands to Python functions and operators?
<ggole> So you can do ls() | grep("foo") or whatever
<gasche> my personal interest being the fact that it runs in a software environment where printing nice graphics or returning interactive data is possible
<ggole> Yes, bash is awful for that
<gasche> (which is a capacity that our terminals are still sadly lacking; I want my shell to be less like screen+{bash,zsh} and more like a Maple/Matlab/Mathematica/Sage session)
<ggole> The Lisp Machine was a bit like that in some ways
<ggole> It's a shame that such approaches were crushed by the industry and have been forgotten
<ggole> And of course there's little or no interesting in changing bash at this stage
<nicoo> gasche: AFAIR, Emacs' eshell is a bit like that (you can run lisp code inside the shell)
<ggole> Hmm, I've seen that before
<gasche> avsm: Termkit made a lot of buzz but died in practice
<ggole> Dunno about how wise it is to build a shell on a web browser
<ggole> And cat image.jpg shows the image? That doesn't help people. That's just shiny fluff.
<gasche> PowerShell + PoshConsole look to have survived
ontologiae has quit [Ping timeout: 264 seconds]
<gasche> ggole: I wouldn't dismiss the idea that sometimes, text may not be the best format to transfer information
<ggole> Of course, that's the strength and weakness of the unix shell.
<gasche> well maybe I'm actually looking for a specific picture in a folder of pictures, and a thumblr view, yes, in the terminal, would be what I need to find it quickly
<ggole> Then you have something for that: ls | thumbs or whatever
<gasche> (so why not 'cat image.jpg'; in fact I have needed exactly this in the past)
<gasche> well you can also do 'xv image.jpg'
<gasche> in practice I often feel like my workflow would be more efficient if it did not open a separate application
<avsm> sounds like you just need a normal shell and xmonad workflows
<ggole> A visualisation tool would be useful, yes
<avsm> termkit died because a linear pad is pretty limited
<ggole> But cat is catenate... I guess I'm complaining about the name, not the utility
<gasche> avsm: what is a "linear pad"
<gasche> ?
<ggole> It would be nice to mix programmatic and user tools, too
<gasche> (quick google search returns discussions about tampons)
<ggole> I'd like to be able to do generate | pick | grep, where pick lets the user select/deselect with the mouse
<avsm> heh. when you type, the results are rendered on the 'next line' of the scratchpad
<gasche> ggole: I think the idea was that cat returns whatever information is in the file in stdin, and that the interactive terminal then select the appropriate visualization view for this information
<gasche> (a bit like NextStep services)
<avsm> in xmonad, they're spawned and laid out as separately tiled pads
<gasche> hm
<gasche> I actually prefer the linear behavior to encode a temporal interaction history
<ben_zen> what gets me is that he complains, late in the post, about 'r-xr-xr-x' not providing useful information.
<ggole> gasche: hmm
<gasche> (I use terminals and xmonad, btw.)
<gasche> (but xmonad is most of the time with a single xwindow in fullscreen view, save the systray space)
<avsm> yeah. you can encode fairly sophisticated layout logic like the one you want, if you can be bothered :)
<pippijn> gasche: how do you give systray space?
* avsm can't be bothered
<gasche> I would like the pictures/animations/whatever to be in the shell at the "time" of the command, scrolling to bring them back and forth, etc.
<gasche> I don't think xmonad is the appropriate layer to encode that
<ggole> I wonder what a shell designed like a spreadsheet would be like
<pippijn> xmonad
<gasche> pippijn: the keyword is avoidStruts (which I use with simpleTabbed)
<gasche> I'm not a xmonad guru so I surely found that somewhere around the documentation
<pippijn> yeah, I'm using that for xmobar
<gasche> I don't make a distinction between "systray" and "xmobar"
<gasche> (only using 'systray' as a generic term for xmobar/gnome-panel/whatever)
<pippijn> actually it's not so important for me to see the tray all the time
<gasche> on a completely separate point
<gasche> I'm a bit disappointed than Batteries and Ocamlbuild see relatively few "external" contributions
<gasche> ("external" being hard to define for batteries that have actually no real notion of "internal" developer; in fact for OCamlbuild it would be equivalent to "anybody" as well)
<avsm> the problem with ocamlbuild is that it doesnt quite solve anyone's problems
<gasche> yet people actually use it
<gasche> I agree than in both cases there are excellent alternatives
<avsm> need to build large repositories? out of luck. need to link C code? write a plugin. need to add a flag? write a plugin if the tag doesnt exist. typo in a tag? silent failure, tag names arent typed checked
<gasche> but the fact is that even if people seem to see enough value in the software to use it, I am under the impression that they see imaginary barriers to contribution
<avsm> so I definitely think it's time to have one good build system, but I don't think that's ocamlbuild
* companion_cube uses ocamlbuild, but has simple needs
<ggole> OCaml has too many build systems already
<gasche> avsm: I'm not really trying to make a point about ocamlbuild per se
<gasche> I mean, I know people having complex needs don't really like it, and I'm fine with them using whatever they want
<gasche> my point would rather be
<avsm> i'm just curious to know why you're disappointed about the lack of contributions
<avsm> since if it doesnt solve a problem at hand, it's hard to justify contributing to (i.e., I dont use Batteries, hence I dont contribute to it)
<gasche> this is a piece of software that is open to contributions from all, has no licence inconveniences, and a relatively low barrier to entry technically-wise
<gasche> and yet people don't send patches
<avsm> ocamlbuild? holy crap, it's complicated on the inside
<gasche> well
dsheets has quit [Ping timeout: 264 seconds]
<gasche> I've fixed bugs for it, it's not terribly hard
<gasche> grep your way around the source, change some stuff, check that it still works
<gasche> I'm not saying everything is clear in the source code or that all issues with it are easy to solve
<avsm> right, so then you have to wait for another compiler release. how do you build you project in the meanwhile?
<avsm> a plugin is the only practical answer
<gasche> (performance issues seem delicate to attack for example)
<avsm> and then i left XXX in there to figure out the upstreaming, and then eventually got so frustrated we started investigating alternatives (obuild, ocp-build, etc)
dsheets has joined #ocaml
<avsm> decoupling ocamlbuild from the tree makes a lot of sense
<gasche> that may happen in a reasonable future
<gasche> I sometimes hear people groaning about the OCaml distribution not being open to contribution
<gasche> but it often looks like people don't even try
<gasche> (OCamlbuild would be one example of honeypot I use to measure the tendency of OCaml users to send patches to help with stuff; Batteries being another one, completely independent)
<avsm> i'd like a 'how to contribute' page on ocaml.org actually. most people get confused about which tool is owned by who
<avsm> i.e. most opam bug reports go to the wrong place ;-)
<ggole> Most people just want to use tools, not contribute to them. That's life.
<smondet> by the way, am I the only one trying Jenga? https://github.com/janestreet/jenga
<avsm> smondet, i'm compiling it right now in fact
<smondet> (Jane St's build system)
<avsm> linux only, so had to install a vm
<avsm> its Async build rules are incredible
<pippijn> smondet: nice
<pippijn> monads :)
<gasche> ggole: (1) I believe some other communities have more contribution, even normalized with respect to size (2) I hear people complaining about contributing being hard, not about not needing/wanting to contribute
<ggole> gasche: hmm, maybe
<gasche> hm
<gasche> interesting, Jérémie is licensing OCaml code under an Apache license
<ggole> I think the number of people making contributions to, say, the C toolchain approximates 0% pretty well though
<ggole> On the other hand that's old and stable by now.
<smondet> avsm: achtung, the version in opam won't work: https://github.com/janestreet/jenga/issues/2
<avsm> smondet: brrr. i'll bug shinwell tomorrow
<avsm> gasche: all of Core is now Apache2
<gasche> I was thinking "OCaml distribution code"
<gasche> but why not
asmanur has quit [Ping timeout: 245 seconds]
<gasche> ggole: you mean clang ?
<gasche> (ok, cheap shot)
asmanur has joined #ocaml
<ggole> I was thinking of binutils and gcc
<gasche> well people contribute to gcc all right
<ggole> As a percentage of those that use it?
<ggole> llvm is certainly moving faster: I should have thought of it before commenting
<gasche> one hurdle for GCC (or LLVM as opposed to frontend-ish activities around Clang) is that it requires a high level of technical knowledge
<gasche> concretely the person I know that contribute to GCC are doing compilation research
<ggole> Yeah. And the code is pretty terrible in spots.
frogfoodeater has quit [Ping timeout: 264 seconds]
<ggole> I tried to understand reload.c once.
<gasche> indeed, indeed
<avsm> most gcc contributions are from people paid to do so, e.g. mentor graphics
<avsm> maintaining a particular backend
<gasche> Batteries for example had a much lower barrier to entry
<ggole> And there's a small core group that do most of the real work
<avsm> ocaml's actually doing pretty well for community contributions in the right places: OPAM has filled up nicely
<ggole> But I guess that's true of many projects
<gasche> (to send a patch you only have to have a useful piece of code, or write some unit tests for existing ones)
<gasche> avsm: I wouldn't really count OPAM as a "community contribution"
<avsm> what would you count it as?
<gasche> Thomas Gazagnaire putting on grueling amount of work to solve a problem they perceived needed solving
cago has left #ocaml []
<gasche> (partly because nobody had given a damn about making GODI better, in the plenty of years during which it had the potential to become what OPAM is now)
<avsm> so thomas and i spent literally a year screwing around with mirage and build systems before deciding we needed something like OPAM
<avsm> and that's where contributions come from. piss someone off enough, and they'll either fix it or leave
<avsm> we liked ocaml, so we stayed :)
<gasche> I know little about OPAM's history, especially compared to you :)
<avsm> but crucially, it was an external tool that doesn't need anyone elses permission
<avsm> fixing ocamlbuild is just the opposite. someone else's permission and release schedule
<gasche> hm
<avsm> to solve *my* problem
<gasche> the "permission" part does not exists, I think
<avsm> compiler-libs is the best thing to happen to ocaml in ages
<gasche> (I don't know how anyone having had an ocamlbuild patch rejected)
<gasche> the release schedule point is taken
<avsm> permission doesnt mean rejection; it means an async decision
<gasche> funny, I've heard people complaining about that for ocaml.org just yesterday :p
<gasche> do you think it would be possible to have subrepositories for special event pages, whose control you'd land to managers of those events?
<avsm> sure, if that would help michel
<gasche> did he ask commit rights yet?
<gasche> +for
<avsm> nope
<gasche> I advised him to do that
<avsm> but there's no problem with that of course
<avsm> but that's what i mean about permission. it's awkward to ask (what if we say no?)
<avsm> of course, we wouldn't, just as you noted that ocamlbuild never has had a patch rejected
<gasche> yes, but it doesn't really scale to other events
<avsm> solve one problem at a time
<gasche> agreed
<avsm> when you have a million events, deal with it. git can revert
<gasche> (but then you have the risk of not noticing the work load because it's amortized/incremental)
<gasche> regarding external contributions
<gasche> I recently found out that Benoît Vaugon, the OcamlCC developer, has excellent bug reports and patches against the compiler hidden under his desk
awm22 has quit [Quit: Leaving.]
<gasche> which he never considered submitting because "it's well-known that INRIA folks don't like external contributions"
<avsm> hah!
<Yoric> Nah, that could never happen.
<gasche> I mocked him a bit, and am now awaiting for the goodness (he's working on the patches for submission, which takes some time as it's part-time work like it is for mostly everyone, and not really small)
<gasche> mostly, he may get rid of some of the ugly things in the way Printf/Scantf/Format work (you don't really want to know), getting a speed boost as a side-effect
<gasche> avsm: have you followed Alain's extension_points work?
<gasche> he's looking for guinea pig extension writers
RagingDave has joined #ocaml
darkf has quit [Quit: Leaving]
<pippijn> http://paste.xinu.at/KekKUh/ <- is this considered good or bad style?
awm22 has joined #ocaml
<gasche> pippijn: List.filter?
<gasche> (I object to the use of name 'x' to denote a list)
<pippijn> gasche: it would have to be rev_map+filter, then
<gasche> you really need the order reversal?
<pippijn> no, but I don't need the order to be preserved and rev_map is faster
<gasche> are you really performance-bound here? then ok do it in one pass
<ggole> Or use, cough, arrays
<Kakadu> gasche: Can u point to some examples of this 'extension_points'?
<gasche> sure, wait
<pippijn> let simplify_list l = List.filter DremlOps.is_empty_language (List.map DremlOps.simplify l)
<pippijn> or better, |-
<gasche> that's the link to the documentation; there are no proper "examples" I would be happy with right now
<pippijn> let simplify_list = List.map DremlOps.simplify |- List.filter DremlOps.is_empty_language
<ggole> OCaml doesn't do any fusion afaik, so that'll cons extra list structure.
<ggole> Of course you may not care.
leoncamel has quit [Quit: WeeChat 0.3.9.2]
<gasche> you can have fusion for free using your lazy enumeration structure of choice
<pippijn> I'm not actually concerned with performance right now
<pippijn> the lists are also very short
<gasche> (not really free, but hm)
<pippijn> so the lazy thing will cost more
<gasche> then that's probably the best solution
<ggole> Every now and then, not often, I miss CL's loop in OCaml.
<ggole> Heresy, I know.
<pippijn> loop?
<ggole> A crazy, complex macro that covers many iteration cases
<ggole> Makes it particularly easy to construct lists without extra consing
<gasche> feel free to express it as a combinator library
ollehar has joined #ocaml
<ggole> I think that would be difficult
<gasche> ollehar: I recommend you have a look at VeriML if you have time
<gasche> it's not quite the kind of dependent crazyness you're looking for
<ggole> And it isn't the hard part of writing software anyway
ontologiae has joined #ocaml
<ggole> Just nice to have
<gasche> but it's fairly interesting and the implementation is still fresh: if you push the authors around, you may get them to develop it more
<gasche> ggole: I'm not terribly familiar with CL's loop (seen a couple examples now and then), what would be particularly hard as a combinator library?
<ollehar> gasche: oh, hello! :) yes, I'll look into that
<gasche> one issue would be the syntactic compactness
<ggole> Yeah, there are a ton of special cases
<ggole> Which is part of why loop is widely vilified
hkBst_ has quit [Ping timeout: 264 seconds]
<gasche> ggole: googling for "CL loop combinator library" returns http://www.mlton.org/ForLoops
<ggole> Now that I think about it, I believe loop relies on mutating the cons cells
<gasche> not as featureful
<ggole> Which would involve a write barrier hit
<gasche> but still a start in the direction I was thinking of
<ggole> I'll have a look
<gasche> it's a proof of concept not aimed at CL's loop precisely
<gasche> not a serious contender
hkBst_ has joined #ocaml
hkBst_ has quit [Changing host]
hkBst_ has joined #ocaml
<gasche> but I'm sure you could get something interesting if following along this path
<gasche> you could reify the loop description as a datatype (probably a GADT, so painful type hacking ahead), and then express optimizations rules as rewrite on this datatype
<gasche> that's the kind of thing that makes me want to just put out an internship description right now
<ggole> Rewrite rules seem preferable to the hard-coding of loop
<ggole> It even has common accumulation idioms built in
<ggole> (loop for i maximizing i into max, minimizing i into min finally return (list min max))
<gasche> (not sure what you mean by "the hard-coding of loop" or "rewrite rules"; are you talking about GHC-like rewrite pragmas?)
jon-shape has quit [Read error: Connection reset by peer]
<ggole> Something like that, yeah
<gasche> rewrite pragmas are very brittle and rather uniformly complained about in the GHC world
<ggole> On the other hand, loop is uniformly castigated in the CL world for being limited and non-extensible
<gasche> that is probably because macros
hkBst_ has quit [Remote host closed the connection]
<ggole> Macros are incredible when you need them and awful when you don't expect them.
mika1 has quit [Quit: Leaving.]
<ggole> Not worth the trouble, I think
hkBst_ has joined #ocaml
hkBst_ has quit [Changing host]
hkBst_ has joined #ocaml
<ggole> Btw, when I said "the hard coding of loop" I was referring to the set of data structures loop is designed to work on
<ggole> It's the set that is built into CL
<ggole> Loop has special purpose syntax and optimisations for those, and nothing for user-written code.
<gasche> well that's a general problem people have
<gasche> when I implemented pa_comprehension
<gasche> I designed it so that you could use it with any datastructure module supporting a few primitives (map, filter, etc.)
<gasche> with the assumption that they satisfied some equational reasoning allowing me to do optimizations on top of them
leoncamel has joined #ocaml
<gasche> you could do the same with a combinator library I suppose
hkBst_ has quit [Ping timeout: 264 seconds]
<ggole> Did it work out? Could you write map f (filter pred xs) and get the loop you would have written by hand?
<ggole> (for loop read 'recursive function')
<ggole> I think LINQ gets away with a vaguely similar approach.
awm22 has quit [Ping timeout: 264 seconds]
<ggole> Although I'm not sure how much effective work is done for user written operations.
<gasche> it did compose (map f (map g ...)), same for filter, etc.
<gasche> but there were still more copies than you could wish for written-by-hand code
<ggole> There always are, sigh
<gasche> in general it's not a problem
<ggole> It's hard to optimise that kind of thing
<gasche> (I'm happy to cover the 90% use cases that are outside the critical loop)
<gasche> regarding "ass-kicking specialized compilation of DSL", the Scala folks have been pouring a lot of work on that in the last couple of years
<ggole> For instance you would often like that { a : foo; b : bar; } have the same representation as the same record with all the fields of foo and bar typed in by hand
<gasche> they have a batallion of PhD students on these questions
<gasche> with fairly good results in some problem domains
<ggole> But in order to do it you have to do crazy lifetime optimisations that look at usage over the entire program
<ggole> Scala looks pretty strange through my eyes
<ggole> I'm not sure what to make of it
<gasche> in any case it will not affect general-purpose Scala programs
awm22 has joined #ocaml
<ggole> They have a good name at the moment
<ggole> Let's see if that turns into an interesting amount of real use
<ggole> It would be healthy, I think
<ggole> Sometimes I wonder how important the issue is
<ggole> After all, you can always find the hotspots and write the loop by hand
<gasche> I think the forst hiding the tree here is "heterogeneous computing" and, truth be told, nobody really knows how it will turn out in a few years
<ggole> You mean spreading computation across cores/cpus/gpus/different machines?
<gasche> yes; it's nice that some folks spend their life figuring how to run code on both a CPU and today's GPU, but there is no way to tell whether this hard work will still be relevant in ten years
<ggole> Yeah
<gasche> I'm personally happy to work on matter more distant from the whims of programmers and industry
<ggole> And it seems that it would be so easy to be absolutely killed by sync and transfer costs or various other kinds of overhead
<ggole> Doesn't seem very practical at the moment
<gasche> what the people see is the buzz around this and that dramatic speedup in well-chosen cases
<gasche> (heck, they are people writing asics to mine bitcoins nowadays)
ocp has quit [Ping timeout: 260 seconds]
<ggole> Yes, like simd code. When it works, it is fantastic. But it almost never works.
<gasche> people rarely have regard for the man-years spent by engineers to make the technology bearable
<gasche> they're happy to just think that Javascript is fast for free nowadays
<ggole> Yes, there's decades of research behind that.
<ggole> And for such a crummy language.
<ggole> Of course it's the platform that they are investing in, and javascript is just along for the ride.
<ggole> I've long thought that systems designers were dropping the ball with regards to how people programmed machines to use networks: it turns out that browsers are the answer.
<ggole> Kind of funny to see compilers get sexy again as a result.
<ggole> It is clearly a new wave of systems work.
* ggole afk for half an hour
ontologiae has quit [Ping timeout: 255 seconds]
<gasche> avsm: does your project on security-by-capabilities have had things to show recently?
<gasche> I just saw that Google poured a bit more money into Capsicum+FreeBSD
chambart has quit [Ping timeout: 245 seconds]
beckerb has quit [Ping timeout: 245 seconds]
ocp has joined #ocaml
tane has joined #ocaml
<avsm> gasche: yes. working hardware and 6000+ freebsd mips packages booting on cheri
<avsm> (and sometime soon, OCaml+capabilities, although that work's just started)
<gasche> that's interesting
<gasche> what I remember from the Emily work is that it mostly works "as is"
<gasche> (removing the ugly stuff from the stdlib, of course)
<gasche> do you have more specific things in mind, like language-level changes?
<gasche> (hm, surely they disabled global references as well)
wmeyer``` has left #ocaml []
eikke has quit [Ping timeout: 245 seconds]
ocp has quit [Quit: Leaving.]
ttamttam has quit [Quit: ttamttam]
chambart has joined #ocaml
<ggole> Hmm, quite clever use of infix operators in that SML library
<ggole> I'm not quite sure how one would write the equivalent of collect ... into ..., but that's not a common case
gnuvince has quit [Ping timeout: 240 seconds]
ontologiae has joined #ocaml
ben_zen is now known as Nikola_Tesla
Nikola_Tesla is now known as ben_zen
Yoric has quit [Ping timeout: 246 seconds]
<hcarty> gasche: To comment on the discussion from a while ago - There has been a lot of noise about how hard it is to get contributions accepted in OCaml. I expect that reputation prevents many from trying. For Batteries the barrier may just be that people don't need a lot more than it provides.
<ollehar> gasche: matter more distant from programmers? what are you working on, really?
<ollehar> *matters
<gasche> from *the whims of programmers*; programmers are still at the heart of the matter
<gasche> right now, I'm doing type theory and proof search
<gasche> but those are knowledge domains that I bet will remain relevant 50 years from now
<gasche> anyway
<gasche> hcarty: I'm willing to make effort to get more contributions to the global OCaml ecosystem
<gasche> (I don't believe that the compiler sources themselves are the best place for contribution; but I'm just a bit surprised to hear this noise that I think is, for the most, misguided)
<gasche> what I'm rather happy with, on the other hand, is the fact that OPAM and the surrounding work (quality analysis with Ocamlot, etc.) may make it easier to organize contributions in a *decentralized* way
<hcarty> It's certainly easier now to take advantage of external effort now
<gasche> my personal hope is that maybe we won't need large "standard library" monoliths anymore in the future, but be able to do more mixing of smaller libs
<gasche> hm
<gasche> maybe we should think of splitting Batteries into submodules for this purpose
<gasche> (where that makes sense, which is probably not a trivial question)(
<hcarty> Trying a project like merlin before opam would have been prohibitive enough that I likely wouldn't have tried it pre-opam, for example.
<gasche> hm
<hcarty> And merlin is a wonderful, non-core tool
<gasche> in this particular case I used merlin from git as it was still fast-moving
<gasche> but yeah
<gasche> same thing for BER-MetaOCaml
<hcarty> gasche: I think the original, external opam repository for merlin pulled from git master
watermind has joined #ocaml
<rks_> it did yeah
<gasche> so what do you think are the current "pain poins" around OCaml right now?
<gasche> +t
<flux> paint poins :)
<gasche> five years ago I was sure it was the stdlib
<gasche> I don't think that's really the case anymore
<hcarty> gasche: If Batteries is going to split, names could be a problem
<gasche> yeah, namespaces, well, don't get me started on that :p
<hcarty> gasche: I don't know what the correct method is for handling this - I've seen your comments on the list :-) - but for example Perl + CPAN does well with this in my experience.
<gasche> I think just maybe with batteries-foo as opam package name, and the BatPrefix preserved could be an interesting start
<gasche> when we get proper namespace support we can still adjust
<gasche> in fact
<gasche> I have a personal idea about what my opinion of the major pain point in OCaml is
<gasche> we need a source-to-source rewriting tool
<flux> ..really, the lack of source-to-source tool is ocaml's major pain point?
<flux> (although I think we do have it in camlp4 and probably that ppx (?) as well)
<hcarty> gasche: Like gofmt?
<gasche> yes
<gasche> flux: well, that's what I have in mind at least
ontologiae has quit [Ping timeout: 240 seconds]
<gasche> of course you can still ask for ponies and "heap of contributed libraries", but that's not really something you can fix with a targeted effort
<gasche> hcarty: we're not far from it
<flux> despite what many think about the right way of approaching the multi-core world, I still think that the lack of multithreading gc is keeping ocaml back
<gasche> I would like to have a tool that takes an OCaml typedtree with location information that is *slightly* off (because it was modified by some tool from a previous source code), and print it back in such a way that all the stuff that hasn't changed is exactly preserved
<flux> if not directly by keeping certain kinds of problems from being solved in ocaml, but indirectly by causing anxiety in C/C++ fold who would like to try ocaml :)
<hcarty> gasche: I think the most significant pain point in OCaml varies depending on the user you'r talking about
<gasche> flux: you mean as a marketing/communication stuff?
<flux> and another is that writing C library bindings is too difficult and very easy to mess up
<gasche> that's right
<hcarty> gasche: For someone new to the language, saying 'Yeah, use vim or emacs!' is probably not helpful.
<ggole> I find the toplevel system remarkably annoying
<gasche> ggole: try utop
<flux> I think there are guis and eclipse plugins for ocaml, but hardcore ocaml folk don't use them, so they don't get that much interest
<ggole> gasche: I'll have a look
<hcarty> flux: There are, but they don't seem to be as stable or feature-rich as the vim and emacs support
<hcarty> flux: In a perfect world ocp-indent, merlin and similar tools would provide a toolkit used by any editor to support OCaml
<ggole> Does it still do annoying things like print abstract types as <abstr>?
<hcarty> gasche: For existing users there are a handful which range in significance. Uncertainty over camlp4 is one issue, particularly with -ppx coming.
ttamttam has joined #ocaml
<hcarty> The idea of an OCaml platform is neat, but it's so vague at this point (OCaml + opam + <is there anything else required?>) that it can be equal parts exciting and worrisome as an observer.
<hcarty> I'm very happy at the moment with OCaml 4.00.1 + opam + Batteries as a core but that combination is only recently available. It will take some time for these tools to become widely used and accepted.
watermind has quit [Quit: Konversation terminated!]
<ggole> I installed OCaml through a package manager: an old version which comes with exactly none of that
<ggole> I suspect a fair number of people would do the same
<hcarty> ggole: That is a big barrier and part of why making it easy to install new versions of OCaml is so important
<ggole> Yup. Some distros are quite conservative though, and any new arrangement will take a long time to become commonplace.
<hcarty> Making those easy install methods the 'normal' way to get OCaml is importnat too so everyone can take advantage of the latest and greatest
<hcarty> Not everyone will want to
<ggole> Well, the alternative is to have your own 'platform' of sorts.
<ggole> Which can be as up to date as you like
<ggole> But it's a lot of work.
chambart has quit [Ping timeout: 248 seconds]
dsheets has quit [Ping timeout: 240 seconds]
<hcarty> We're part way there with opam - on non-Windows platforms (?) it's now fairly easy to get up and running with the latest OCaml release.
<ggole> That's a definite plus.
<ggole> I should probably be using opam
<hcarty> opam still has some significant dependency handling bugs but it already makes it a matter of a few commands to go from no OCaml to latest stable + the libraries and tools you want.
eikke has joined #ocaml
<hcarty> gasche: The modified error message through on caml-list is an example of hostility toward changes. I would love to see error messages which are more human friendly but there was immediate animosity toward a proposed change to provide that.
chambart has joined #ocaml
<rks_> hcarty: second that
<rks_> I'll add that the argument against such a change is pretty sad "my emacs knows how to read the actual error messages, so the rest of the world can go f*** himself"
ontologiae has joined #ocaml
<thomasga> hcarty: do you have dependency bugs in master or in 1.0.0 ?
<thomasga> (for opam)
<hcarty> thomasga: 1.0.0
<hcarty> thomasga: I haven't tried master but I think from our previous discussions that it has been fixed there.
<hcarty> rks_: Indeed
<hcarty> thomasga: I have had issues with ocamlnet under opam. When I tried to upgrade from 3.6.0 to 3.6.3 opam said it had removed all of the ocamlnet modules but ocamlfind complained about some of the packages still existing when it tried to install 3.6.3.
<hcarty> thomasga: I don't know if this is a packaging issue or opam issue.
<thomasga> hcarty: indeed, the heuristic should be better now (and if you are on debian, I would advise to try 'apt-get install aspcud` which is a far better solver than the one in OPAM, although the one in master should be fine for most of the cases)
eikke has quit [Ping timeout: 252 seconds]
<thomasga> ha
<thomasga> seems to be a package description issue
<thomasga> not a dependency issue
mcclurmc has quit [Ping timeout: 252 seconds]
<hcarty> thomasga: Thanks for the aspcud tip. I am using opam on RHEL/CentOS in this case so I'll have to try master/wait for the next release.
chris2 has joined #ocaml
<chris2> hi. are there ocaml libraries implementing applicative functors in the haskell meaning of that term?
djcoin has quit [Quit: WeeChat 0.3.9.2]
zpe has quit [Remote host closed the connection]
dsheets has joined #ocaml
chambart has quit [Ping timeout: 272 seconds]
Nahra` has joined #ocaml
ontologiae has quit [Ping timeout: 245 seconds]
ttamttam has quit [Ping timeout: 272 seconds]
Nahra` has quit [Remote host closed the connection]
ttamttam has joined #ocaml
<hcarty> chris2: http://blog.0branch.com/from-functor-to-applicative - found this in a search
wmeyer has joined #ocaml
<chris2> hcarty: thanks!
<chris2> hcarty: searching for applicative functors yields mostly module-level results ;)
<hcarty> You're welcome - I'm happy to now know what an applicative functor is in the Haskell world :-)
<chris2> hehe
<chris2> now i "just" need to port idiom brackets to camlp5 :P
ben_zen has quit [Ping timeout: 264 seconds]
Yoric has joined #ocaml
malo has quit [Quit: Leaving]
ben_zen has joined #ocaml
tane has quit [Quit: Verlassend]
gustav__ has joined #ocaml
gustav has quit [Quit: leaving]
nongeek has joined #ocaml
Nahra has quit [Remote host closed the connection]
nongeek has quit [Read error: Connection reset by peer]
Nahra has joined #ocaml
zpe has joined #ocaml
ttamttam has left #ocaml []
zpe has quit [Ping timeout: 272 seconds]
dsheets has quit [Quit: Leaving]
chambart has joined #ocaml
ggole has quit []
gnuvince has joined #ocaml
ocp has joined #ocaml
<def-lkb> '
Trollkastel has joined #ocaml
Kakadu has quit []
<adrien> `
<def-lkb> adrien: thx, I was feeling alone
<adrien> well, you are: everyone is still wondering how you put that into irc
<adrien> at least when people do "ls" in IRC, it's a full command
<adrien> but ' ... =P
<adrien> pssshttttt beer \o/
<def-lkb> :)
<pippijn> sometimes I do :x or :q in IRC
<pippijn> I rarely do "ls" in the terminal, either
<pippijn> I rarely *only* want to know what's in a directory
<pippijn> usually I want to do something (vi, cd, less, cat, ...), so I use tab completion
<pippijn> which is smart, for example in that cd <tab> only shows directories
UncleVasya has quit [Quit: UncleVasya]
smerz_ has joined #ocaml
troydm has quit [Read error: Operation timed out]
troydm has joined #ocaml
<adrien> I do /beginning/of/path/<tab><tab> instead of ls ;-)
<companion_cube> ls brings you shiny colors
<companion_cube> so ls is good
Snark has quit [Quit: leaving]
<hcarty> 'ls -lrt' lets you know what's been updated recently. ls, again, is good.
<adrien> companion_cube: zsh has colours in the tab completion
<companion_cube> hmm, right
ewanas has joined #ocaml
breakds has quit [Quit: Konversation terminated!]
_andre has quit [Quit: leaving]
chambart has quit [Ping timeout: 246 seconds]
Trollkastel has quit [Read error: Connection reset by peer]
Trollkastel has joined #ocaml
<bernardofpc> (and you can also tweak autocompl to have the most recent at the top, so vim TAB TAB edits what you think)
cdidd has joined #ocaml
wmeyer has quit [Remote host closed the connection]
malo_ has joined #ocaml
wmeyer has joined #ocaml
pkrnj has joined #ocaml
mcclurmc has joined #ocaml
smondet has quit [Ping timeout: 259 seconds]
gautamc has joined #ocaml
Trollkastel has quit [Read error: Connection reset by peer]
jbrown has quit [Ping timeout: 246 seconds]
<wmeyer> gasche: regarding recent discussion about ocamlbuild (apologises to not chime in, but I had the acces to IRC in the end of the day), that I'd like to see more patches coming to ocamlbuild and I can promse that they will be integrated quickly. So far there have been few very useful patches. At all ocamlbuild is not that complicated beast, and it does have now decent testsuite!
<wmeyer> so people please use the bugtracker and send your patches. Git formatted patches are always welcome.
jbrown has joined #ocaml
Trollkastel has joined #ocaml
* adrien wonders if that discussion was on platform@
<wmeyer> unfortunately wasn't, but platform suppose to come up at some point with discussion about build systems
* adrien wonders where it was then
<wmeyer> adrien! stop! :-)
* wmeyer has some plan about ocamlbuild
<adrien> I'm really wondering: I didn't see anything
<adrien> anyway, bedtime, good night
<wmeyer> adrien: night; thanks
RagingDave has quit [Quit: Ex-Chat]
pkrnj has quit [Quit: Computer has gone to sleep.]
Yoric has quit [Ping timeout: 252 seconds]
thomasga has quit [Quit: Leaving.]
<ewanas> Hi all.
<ewanas> Is there anything needed to be done with opam, other than opam config env to allow me to use the libraries I installed?
<gautamc> hi, When I type (+);; (=);; (:=);; etc in the toplevel, it shows the type signature for these operators. But, when I type (<-);; in the toplevel I see an error - I am trying to see the type signature for <- .This is the assignment operator for mutable arrays ( let a=[|1 ; 2 ; 3 |];; a.(1) <- 22;; ). Is the <- "operator" not really an operator? (I've started to learn ocaml recently and from what i understand every operator is a function and t
<companion_cube> I think <- is a builtin
<gautamc> ok. will google ocaml bultins.. thnx
<companion_cube> I mean, it's really in the language, unlike (=), (+) and (:=) that are standard functions
<gautamc> ok!
<gautamc> that makes sense
<companion_cube> it's like a.b = c; in C-like languages
<bernardofpc> but isn't + in C "part of the language" in the same way ?
<bernardofpc> (contrary to (+) in OCaml, which is *not* part of the languate)
<companion_cube> I think so
<companion_cube> well, (+) exists in ocaml even if you don't link against Pervasives, I believe
<companion_cube> but it still behaves like a function
<ewanas> Here's cleaned up output(removed other stuff that was in the path) of opam config env: https://gist.github.com/anonymous/5416620
ocp has quit [Quit: Leaving.]
<ewanas> It *seems* like it's not including ~/.opam/system/lib which I think should be(based on ls'ing there, I see all the folders for what I installed)
<yezariaely> bernardofpc: How can + not be part of the language? I assume naturals are not build as Zero and Succ in Ocaml...?
<wmeyer> so <- is hardcoded deeper than +, <- is already a separate parse tree node, where is (+) still behaves like an operator, even though it gets propagated to the code generator
<yezariaely> that makes sense.
gautamc has left #ocaml []
<Cypi> companion_cube : it doesn't
<wmeyer> Cypi: I think it does
<Cypi> Oh wait.
<Cypi> Hum, indeed, I don't know what I teste that didn't work with -nopervasives...
<Cypi> tested*
<companion_cube> still, (+) is probably part of ocaml -nopervasives
<companion_cube> because you cannot implement it without the language supporting it
<companion_cube> (unlike lists, hashtables etc.)
<wmeyer> another reason for that is that it's a really part of all the intermediate languages, primitive plus operation on integrals
<wmeyer> so it's not worth to decouple that
<wmeyer> List is also builtin
<wmeyer> and option type too
<companion_cube> yes, but list does not really need to be builtin, does it?
<companion_cube> apart from the special syntax
<wmeyer> yes, I didnt't see any reasons for that from top of my head, when I was looking into that code
<wmeyer> but then how would you implement the syntax without implementation?
<wmeyer> I can see strong reason for option type, as it's part of the labelled optional function arguments
malo_ has quit [Quit: Leaving]
eikke has joined #ocaml
<companion_cube> true
frogfoodeater has joined #ocaml
<wmeyer> I think general lists are very basic data types, so they deserve to be builtin
<wmeyer> yezariaely: integers are builtins for performance reasons, they basically work the same way as in C compiler.
<companion_cube> not exactly though, because of the GC bit
<fasta> The only reason languages define a syntax is vendor lockin, speed and applying typing-rules.
frogfoodeater has quit [Ping timeout: 255 seconds]
<companion_cube> vendor lockin ??
<orbitz> that's not true
pkrnj has joined #ocaml
<fasta> companion_cube: yeah, the only reason you are writing OCaml code is to keep people who write OCaml compilers relevant.
<companion_cube> I lol.
<companion_cube> I write OCaml because it's the most convenient tool for what I do
<fasta> companion_cube: so, security isn't one your interests?
<wmeyer> companion_cube: yes
<companion_cube> fasta: security?
<orbitz> fasta: I don't understand what you're trying to say? I find ocaml syntax lighter than, for example, erlang ysntax, which is one reason I write ocaml
<wmeyer> fasta: ??
<companion_cube> what do you mean by security in this context?
<fasta> companion_cube: yes, OCaml contains a blob, just like the nvidia kernel module in Linux.
<companion_cube> sooooo.... what ?
<fasta> companion_cube: there is no fully 'open-source' OCaml system.
<companion_cube> what's the blob you're talking about? the GC?
<fasta> companion_cube: so, that initial blob can contain arbitrary code.
<eikke> fasta: which blob are you referring to?
<fasta> eikke: something used for bootstrapping.
<fasta> I think GHC has gone along the same rather stupid path where it is almost impossible to bootstrap the system from nothing.
<eikke> ah, that one
<eikke> ghc needs another ghc installed
<orbitz> fasta is on one of his nonsense streams again, probably best to ignore him
<companion_cube> orbitz: come on, NSA may have put a backdoor in the GC!
<companion_cube> that's probably why it pauses the program sometimes.
<fasta> orbitz: it seems more like a vacuous trivial truth.
<wmeyer> fasta: if you could present your thoughts in more friendly way, we can accept your "bootstrapped blob theory"
<eikke> companion_cube: yeah, GC pauses are caused by your heap being transferred to the closest NSA datacenter ;)
<fasta> Now, of course, your CPU can also contain a backdoor, but it's certainly not an advantage to have such blobs.
<fasta> So, when Linux users go berserk when they have such in their systems, why shouldn't we question it if the same happens in a compiler?
<companion_cube> or even my BIOS
<fasta> I think there is no excuse to distribute such compilers in 2013.
<companion_cube> fasta: so how do you want it to be bootstraped§
<companion_cube> ?
<fasta> companion_cube: asm -> Forth -> <intermediate language> -> OCaml.
<companion_cube> pifu
<fasta> companion_cube: all properly annotated.
<companion_cube> pfiu*
<companion_cube> and what about the BIOS?
<companion_cube> or EFI or whatever
<fasta> companion_cube: and preferably everything should come with proofs.
<companion_cube> proofs need a tool to be checked
<fasta> companion_cube: the BIOS should be kicked out, I think ARM already does that.
<companion_cube> I hope you're conscious of the huge amount of efforts your solution requires
<fasta> companion_cube: that would be irrelevant.
<fasta> companion_cube: I am merely answering your question.
<fasta> companion_cube: "how do you want it to be ..."
<orbitz> companion_cube: please starty your sentences with fasta: so my /ignore will work, thank you :)
<companion_cube> :D
<fasta> Why exactly is he ignoring me?
<fasta> Is it too obvious what I am suggesting and does he only want to hear about short term improvements that lead to nowhere?
<ewanas> I see no reason for it, but then again, this is 2013.. ugh.
<companion_cube> fasta: probably because you're attacking ocaml for no real reason
<fasta> companion_cube: again "no real reason".
<fasta> companion_cube: did I not also 'attack' GHC too?
<companion_cube> well, you're probably the only one here that is so concerned by a blob used for bootstrapping
<companion_cube> we don't care about GHC
<fasta> companion_cube: fact is that most people on this planet don't build perfection.
<eikke> companion_cube: actually I do, quite a bit
<fasta> companion_cube: where most is around 99.99999% if not more.
<companion_cube> eikke: traitor! ;)
<fasta> I am just reminding you that not everything has to suck.
<companion_cube> fasta: good luck with perfection
<eikke> companion_cube: if only you'd know...
<companion_cube> especially if you consider that not perfect <=> sucks
<wmeyer> fasta: please write your compiler. Which will include features your dream about.
<companion_cube> anyway, time to sleep
<wmeyer> fasta: and good luck :-)
<companion_cube> yeah, fasta, then you'll be able to use your language to bootstrap ocaml easily
<wmeyer> actually his idea of bootstrapping from Forth and Lisp is nothing new
<wmeyer> but does not apply in real life unfortunately. fasta please try! :D
* wmeyer stopped reading when heard about "boostrapped blobs"
AdmWiggin has quit [Ping timeout: 252 seconds]
tianon has joined #ocaml
frogfoodeater has joined #ocaml
fraggle_ has quit [Ping timeout: 246 seconds]
Trollkastel has quit [Quit: Brain.sys has encountered a problem and needs to close. We are sorry for the inconvenience.]
fraggle_ has joined #ocaml
walter|r has joined #ocaml
Trollkastel has joined #ocaml
gautamc has joined #ocaml
<bernardofpc> companion> not exactly though, because of the GC bit -> and therefore much confusion ensues :P
emmanuelux has joined #ocaml
ollehar has quit [Ping timeout: 245 seconds]
darkf has joined #ocaml
ollehar has joined #ocaml
jbrown has quit [Ping timeout: 258 seconds]
frogfoodeater has quit [Ping timeout: 248 seconds]
q66 has quit [Remote host closed the connection]
pkrnj has quit [Quit: Computer has gone to sleep.]
tattedsxy33 has joined #ocaml
tattedsxy33 has quit [Killed (idoru (Spam is off topic on freenode.))]
tattedsxy33 has joined #ocaml