ChanServ changed the topic of #ocaml to: Discussions about the OCaml programming language | http://www.ocaml.org | OCaml 4.02.1 announcement at http://ocaml.org/releases/4.02.html | Public channel logs at http://irclog.whitequark.org/ocaml
dsheets has quit [Ping timeout: 252 seconds]
AltGr has joined #ocaml
seanmcl has quit [Quit: My MacBook Pro has gone to sleep. ZZZzzz…]
WraithM has joined #ocaml
WraithM_ has joined #ocaml
madroach has quit [Ping timeout: 250 seconds]
AlexRussia has quit [Ping timeout: 244 seconds]
madroach has joined #ocaml
Thooms has quit [Quit: WeeChat 1.0.1]
ygrek has joined #ocaml
manud has quit [Quit: Be back later ...]
manud has joined #ocaml
AlexRussia has joined #ocaml
manud has quit [Quit: Be back later ...]
AlexRussia has quit [Ping timeout: 264 seconds]
antinomy has quit [Ping timeout: 265 seconds]
struktured has quit [Ping timeout: 258 seconds]
struktured has joined #ocaml
ygrek has quit [Ping timeout: 265 seconds]
jao has joined #ocaml
jao has quit [Changing host]
jao has joined #ocaml
antinomy has joined #ocaml
jwatzman|work has quit [Quit: jwatzman|work]
AlexRussia has joined #ocaml
badkins has joined #ocaml
rgrinberg has quit [Quit: Leaving.]
peddie has left #ocaml ["WeeChat 0.4.2"]
hbar has quit [Quit: WeeChat 0.4.2]
andreypopp_ has quit [Quit: Connection closed for inactivity]
Submarine has joined #ocaml
shinnya has quit [Ping timeout: 250 seconds]
ygrek has joined #ocaml
q66 has quit [Quit: Leaving]
rgrinberg has joined #ocaml
AltGr has left #ocaml [#ocaml]
AltGr has joined #ocaml
hbar has joined #ocaml
jabesed has quit [Ping timeout: 244 seconds]
hbar has quit [Client Quit]
hbar has joined #ocaml
darkf has joined #ocaml
AlexRussia has quit [Ping timeout: 245 seconds]
rgrinberg has quit [Quit: Leaving.]
manizzle has quit [Remote host closed the connection]
manizzle has joined #ocaml
AlexRussia has joined #ocaml
bugabinga has quit [Remote host closed the connection]
bugabinga has joined #ocaml
antinomy has quit [Ping timeout: 272 seconds]
manud has joined #ocaml
marynate has joined #ocaml
Valdo has quit [Excess Flood]
Valdo has joined #ocaml
andreypopp_ has joined #ocaml
Submarine has quit [Quit: Leaving]
badon has quit [Disconnected by services]
badon_ has joined #ocaml
badon_ is now known as badon
pyon has quit [Ping timeout: 258 seconds]
w0rp has quit [Ping timeout: 240 seconds]
chaptastic has joined #ocaml
w0rp has joined #ocaml
manizzle has quit [Ping timeout: 250 seconds]
samrat has joined #ocaml
pyon has joined #ocaml
badkins has quit [Remote host closed the connection]
WraithM has quit [Quit: leaving]
WraithM_ has quit [Ping timeout: 252 seconds]
jordjordjord has joined #ocaml
keen_________ has joined #ocaml
keen________ has quit [Ping timeout: 260 seconds]
jordjord_ has joined #ocaml
AlexRussia has quit [Ping timeout: 264 seconds]
jordjordjord has quit [Ping timeout: 264 seconds]
jordjord_ has quit [Read error: Connection reset by peer]
manud has quit [Quit: Be back later ...]
samrat has quit [Quit: Computer has gone to sleep.]
jordjordjord has joined #ocaml
robink has quit [Read error: Connection reset by peer]
AlexRussia has joined #ocaml
robink has joined #ocaml
manud has joined #ocaml
manud has quit [Client Quit]
badkins has joined #ocaml
badkins has quit [Ping timeout: 245 seconds]
goglosh has joined #ocaml
manizzle has joined #ocaml
<goglosh> hello
<goglosh> say, how high-level is ocaml, compared to lisp?
emery has joined #ocaml
NoNNaN has joined #ocaml
<struktured> goglosh: sort of a loaded question, ocaml is not homoiconic and doesn't have things like macros so its a little bit less high level, I suppose. ppx makes up for it though
nicoo has joined #ocaml
<goglosh> yeah you're right, looks like a trick question heh
samrat has joined #ocaml
chinglish has joined #ocaml
marynate has quit [Quit: Leaving]
MercurialAlchemi has joined #ocaml
ygrek has quit [Ping timeout: 272 seconds]
koderok has joined #ocaml
Intensity has quit [Remote host closed the connection]
jao has quit [Ping timeout: 264 seconds]
goglosh has quit [Quit: leaving]
vpm has quit [Quit: co'o]
dsheets has joined #ocaml
koderok has quit [Quit: koderok]
arj has joined #ocaml
vpm has joined #ocaml
dsheets has quit [Ping timeout: 244 seconds]
ogudo26 has joined #ocaml
mearnsh has quit [Ping timeout: 272 seconds]
manud has joined #ocaml
mearnsh has joined #ocaml
koderok has joined #ocaml
jonludlam has quit [Ping timeout: 264 seconds]
ygrek has joined #ocaml
chambart has joined #ocaml
jonludlam has joined #ocaml
manud has quit [Quit: Be back later ...]
ogudo26 has quit [Quit: Leaving]
relrod_ has joined #ocaml
AlexRussia has quit [Quit: WeeChat 1.1-dev]
lordkryss has quit [Quit: Connection closed for inactivity]
koderok has quit [Quit: koderok]
<MercurialAlchemi> just saw the link to the new 'Destruct' functionality in merlin
<ygrek> share it!
<MercurialAlchemi> next thing you know, it's going to write your entire program for you
<flux> I feel betrayed
<flux> it doesn't destroy anything, of course it shouldn't when looking more precisely the name :)
<flux> hmm, actually I was confused, it is indeed a synoym for destroy
<flux> yet it generates code!
<MercurialAlchemi> ":Constructs" sounds wrong though
<flux> ..destructure :)
<flux> pretty nift looking though!
<MercurialAlchemi> yes, it's great
<MercurialAlchemi> now you can go wild with adts and polymorphic variants
<MercurialAlchemi> (where wild < 255, AFAIK)
<flux> does this mean OCaml sucks because we need to generate code in an IDE?-(
matason has joined #ocaml
<flux> we're in the Java camp now!
jonludlam has quit [Quit: Coyote finally caught me]
<MercurialAlchemi> :)
ggole has joined #ocaml
<ggole> rks`: ping
<MercurialAlchemi> I think we have a lot of catching up to do in this direction
<flux> yeah.. not enough XML yet.
<MercurialAlchemi> but if we're going to catch up on anything Java, I'd rather catch up on instrumentation
<MercurialAlchemi> re XML, it's only because you haven't experienced the wonders of .Net that you say that :)
oscar_toro has joined #ocaml
samrat has quit [Quit: Computer has gone to sleep.]
fraggle-boate has quit [Read error: Connection reset by peer]
<def`> :))
<ggole> def`: rks`'s destruct stuff looks really cool
<ggole> But it's throughly broken at the moment (at least in emacs)
<whitequark> def`: merlin again gets confused about ml and mli
<whitequark> wtf?
<whitequark> file called x.ml, error "expecting signature"
chambart has quit [Ping timeout: 250 seconds]
<MercurialAlchemi> "x.ml", that's clearly a provocation
<whitequark> although I probably have been using a stale merlin binary, nevermind
<def`> whitequark: can you share the content ?
<whitequark> "let x = 1"
<def`> :D
<whitequark> it stopped doing that, but now it errors out on match%sedlex
<whitequark> hm, and there is only one ocamlmerlin in path
<def`> ggole: I don't think there is any testing in emacs, but you should wait for rks`
<whitequark> is merlin-ppx branch up to date?
<def`> it should be
<whitequark> also, how come there's no reload command anymore? I have to restart ST to get it to reread .merlin
<ggole> Ah, I think I see (some of the) problem(s)
<ggole> It picks up stale type enclosing state
<def`> whitequark: they are reloaded in bg
<whitequark> they are not
<ggole> This should be easy to fix.
<def`> they should :)
<whitequark> because it doesn't pick up new B paths
<whitequark> and I have no fucking clue how to even debug it, there's no debug output or anything
<whitequark> merlin is completely opaque
<def`> yay, that's lock in strategy
<ggole> Yeah, the debug stuff is too hard to use.
<ggole> It's there, but mostly turned off :/
<ggole> OK, half working now... but the error printing is messed up.
chambart has joined #ocaml
<def`> open an issue, I started working on a companion gui to output log,that's painful and time consuming :)
samrat has joined #ocaml
fraggle-boate has joined #ocaml
<ggole> Ah, that's better.
<ggole> Hmm, this is cool.
<whitequark> oh, okay, ppx thing is due to confusing findlib package name, not a merlin bu
<whitequark> *bug
<def`> the signature problem remains, I suspect a sync issue in ST plugin
<def`> the plan for debugging: open a fifo to output log information and read debug commands, have an external tool for presenting that to the user
<whitequark> can you just put it into an editor pane?
<whitequark> use print() in st that will put it in the Ctrl+~ pane, some equivalent in vim or emacs
jordjordjord has quit [Ping timeout: 245 seconds]
<ggole> emacs already has an optional log buffer
<ggole> It isn't very comprehensible though.
jordjordjord has joined #ocaml
_5kg has quit [Ping timeout: 260 seconds]
_5kg has joined #ocaml
claudiuc has quit [Remote host closed the connection]
jordjordjord has quit [Ping timeout: 264 seconds]
koderok has joined #ocaml
psy_ has quit [Ping timeout: 244 seconds]
koderok has quit [Remote host closed the connection]
larhat has joined #ocaml
kakadu has joined #ocaml
struktured has quit [Ping timeout: 258 seconds]
<rks`> ggole: pong
<rks`> oh ok, broken in emacs
<rks`> ah yes
<rks`> it picks up stale enclosing
<rks`> yes I figured this would happen and I have a solution
<ggole> rks`: I've put a PR that fixes that (and some other things)
<rks`> yes
<rks`> I've seen
<rks`> it's not the fix I expected (nor want actually) though
<rks`> I'll explain why on the PR
<ggole> Sure
milosn has quit [Ping timeout: 244 seconds]
claudiuc has joined #ocaml
oscar_toro has quit [Ping timeout: 260 seconds]
arj has quit [Ping timeout: 252 seconds]
<MercurialAlchemi> companion_cube: when is it more interesting to use 'sequences' than 'gen'? they look fairly similar
gueuldange has joined #ocaml
<gueuldange> bonjour tous le monde, je voudrai savoir si c'est possible de modifier des cellules d'un document excell (.xlsx) avec Ocaml
<rks`> gueuldange: this is an english speaking channel
<rks`> you have #ocaml-fr if you'd rather speak french
<gueuldange> okok ty
<rks`> you're welcome
<rks`> ggole: thanks for your answer!
<MercurialAlchemi> gueuldange: think you're out of luck, there is a decent csv package, but I don't think there is an Excel library
<ggole> rks`: should I update the PR with that change, or do you want to handle it?
oscar_toro has joined #ocaml
<rks`> ggole: the on-exit on the overlay-map?
<rks`> You could do it if it's not too much trouble
<rks`> I don't have the time right now, as I said I won't until later today
<rks`> so if you can give it a go and see whether it works or not it'd be great
<companion_cube> MercurialAlchemi: sequence works easily with existing data structures (only require a "iter" function)
gueuldange has quit [Ping timeout: 246 seconds]
ggole has quit [Ping timeout: 264 seconds]
ggole has joined #ocaml
<ggole> rks`: I've pushed that, but now I'm afk for a bit. Leave a comment and I'll pick it up.
<ggole> Cheers.
<rks`> great, thanks
<MercurialAlchemi> companion_cube: I see - looking at of_list really illustrates the issue
<companion_cube> lists are ok, but look at of_hashtbl or something similar
<companion_cube> you can't do the same with Gen, sadly, because it would require having access to the internal representation of Hashtbl
milosn has joined #ocaml
oscar_toro has quit [Quit: Leaving.]
<MercurialAlchemi> companion_cube: yeah, it's a "don't call me, I'll call you" thing
<companion_cube> exactly
<MercurialAlchemi> which could be adequately solved if hashtables had a to_gen method
<MercurialAlchemi> but then we're back to stdlib issues
<companion_cube> yep
<companion_cube> the other solution is to reimplement/copy existing structures into your own library, which is what Batteries does
<MercurialAlchemi> there goes the 'lightweight' advertising :)
Remyzorg has joined #ocaml
<MercurialAlchemi> companion_cube: is it that unthinkable to patch the stdlib to support something like this?
<companion_cube> well.
<companion_cube> it's easy technically, but getting it merged is hard
<MercurialAlchemi> hell, since we were talking about Java, collections are Iterable...
<MercurialAlchemi> I can't imagine it represents that much code
<companion_cube> it doesn't
<companion_cube> well then, with trees (Map,Set) you could have fancier iterators (like, range of keys)
pgomes has joined #ocaml
<MercurialAlchemi> yeah, but basic iterator support should be, what, maybe 3 methods tops for Hashtbl (keys, values, key/value)
<MercurialAlchemi> maybe even just key/value
<MercurialAlchemi> as opposed to no iterator support :(
arj has joined #ocaml
eyyub has joined #ocaml
<companion_cube> just key/value, indeed
<Leonidas> whitequark: my previous crash with deinitializing the ocaml bindings seems to have fixed itself after I updated to todays llvm and rebuilt.
NoNNaN has quit [Ping timeout: 250 seconds]
chambart has quit [Ping timeout: 244 seconds]
<Leonidas> hmm, or not. maybe I was to quick to declare this solved
arj has quit [Ping timeout: 250 seconds]
sgnb has joined #ocaml
troydm has quit [Ping timeout: 250 seconds]
thomasga has joined #ocaml
troydm has joined #ocaml
axiles has quit [Quit: Quitte]
ygrek has quit [Ping timeout: 256 seconds]
Simn has joined #ocaml
sgnb has quit [Ping timeout: 252 seconds]
arj has joined #ocaml
_5kg has quit [Ping timeout: 258 seconds]
arj has quit [Ping timeout: 260 seconds]
rand000 has joined #ocaml
ygrek has joined #ocaml
oscar_toro has joined #ocaml
oscar_toro has quit [Max SendQ exceeded]
oscar_toro has joined #ocaml
ygrek has quit [Ping timeout: 250 seconds]
chambart has joined #ocaml
arj has joined #ocaml
q66 has joined #ocaml
<kakadu> join #popcorntime
<kakadu> sorry
<adrien> pirate!
<Leonidas> how can I get ctypes to hand my a pointer to a float?
<Leonidas> let myfloat = 3.14;;
<Leonidas> let ptr_to_myfloat = Ctypes.???? myfloat;;
<whitequark> allocate it
<Leonidas> ah
<MercurialAlchemi> adrien: maybe he's streaming OCaml programming livestreams
<Leonidas> Ctypes.(allocate float 3.14);; yay
<adrien> MercurialAlchemi: :)
ygrek has joined #ocaml
oscar_toro has quit [Ping timeout: 245 seconds]
eyyub1 has joined #ocaml
eyyub has quit [Ping timeout: 255 seconds]
axiles has joined #ocaml
samrat has quit [Quit: Computer has gone to sleep.]
samrat has joined #ocaml
avsm has joined #ocaml
_5kg has joined #ocaml
<kakadu> MercurialAlchemi: I thought about that but I don't think that somebody will watch it
jonludlam has joined #ocaml
oscar_toro has joined #ocaml
kakadu is now known as Fifteen_men_on_t
Fifteen_men_on_t is now known as Kakadu
<MercurialAlchemi> Kakadu: don't underestimate OCaml's popularity
<Leonidas> twitch.tv with people hacking ocaml, that would be kinda neat
arj has quit [Ping timeout: 245 seconds]
<MercurialAlchemi> yep
thomasga has quit [Quit: Leaving.]
<MercurialAlchemi> It's really a matter of finding the right title
<MercurialAlchemi> "whitequark sacrifices camlp4 lines to the PPX god LIVE", for instance
<Leonidas> "whitequark removes 4kLOC of camlp4 code and you wouldn't believe what happened"
<MercurialAlchemi> that's the spirit
chambart has quit [Ping timeout: 264 seconds]
_5kg has quit [Ping timeout: 244 seconds]
arj has joined #ocaml
samrat has quit [Quit: Computer has gone to sleep.]
chinglish has quit [Ping timeout: 244 seconds]
arj has quit [Ping timeout: 252 seconds]
<whitequark> lol
jabesed has joined #ocaml
* ggole pictures whitequark on top of a Mayan temple, knife in hand, offering camlp4's beating heart up to the sunset
<companion_cube> \o/
arj has joined #ocaml
<ggole> I'd watch that stream.
* whitequark is currently doing a kind of bone sorcery on ocamlc
<whitequark> (bone sorcery is like brain surgery, except with more magic)
hugomg has joined #ocaml
<MercurialAlchemi> ggole: the problem is that camlp4 is many-hearted
psy_ has joined #ocaml
claudiuc has quit [Remote host closed the connection]
_5kg has joined #ocaml
jonludlam has quit [Quit: Coyote finally caught me]
_5kg has quit [Ping timeout: 272 seconds]
chinglish has joined #ocaml
larhat has quit [Ping timeout: 244 seconds]
badkins has joined #ocaml
jonludlam has joined #ocaml
thomasga has joined #ocaml
JokerDoom has joined #ocaml
shinnya has joined #ocaml
ollehar has joined #ocaml
_5kg has joined #ocaml
_JokerDoom has quit [Ping timeout: 264 seconds]
_5kg has quit [Ping timeout: 245 seconds]
avsm has quit [Quit: Leaving.]
AltGr has left #ocaml [#ocaml]
samrat has joined #ocaml
_5kg has joined #ocaml
ygrek has quit [Ping timeout: 245 seconds]
eyyub1 has quit [Read error: Connection reset by peer]
eyyub1 has joined #ocaml
AlexRussia has joined #ocaml
darkf has quit [Quit: Leaving]
darkf has joined #ocaml
chambart has joined #ocaml
larhat has joined #ocaml
iZsh has quit [Quit: ZNC - http://znc.in]
iZsh has joined #ocaml
antinomy has joined #ocaml
bytbox has quit [Remote host closed the connection]
BitPuffin has joined #ocaml
<arj> can I use more than one paths in an _oasis executable definition somwhow?
<arj> i.e. source paths
maufred_ has quit [Remote host closed the connection]
thomasga has quit [Quit: Leaving.]
chambart has quit [Ping timeout: 244 seconds]
AlexRussia has quit [Ping timeout: 250 seconds]
AlexRussia has joined #ocaml
olauzon has joined #ocaml
darkf has quit [Quit: Leaving]
struktured has joined #ocaml
oscar_toro has quit [Ping timeout: 258 seconds]
davine has joined #ocaml
larhat has quit [Quit: Leaving.]
pgomes has quit [Quit: http://www.kiwiirc.com/ - A hand crafted IRC client]
olauzon has quit [Quit: olauzon]
olauzon has joined #ocaml
q66 has quit [Remote host closed the connection]
q66 has joined #ocaml
antinomy has quit [Ping timeout: 260 seconds]
oscar_toro has joined #ocaml
koderok has joined #ocaml
arj has quit [Quit: Leaving.]
koderok has quit [Client Quit]
olauzon has quit [Quit: olauzon]
olauzon has joined #ocaml
bytbox has joined #ocaml
bytbox has quit [Remote host closed the connection]
ingsoc has joined #ocaml
bytbox has joined #ocaml
chambart has joined #ocaml
ygrek has joined #ocaml
nicoo has quit [Remote host closed the connection]
nicoo has joined #ocaml
bytbox has quit [Ping timeout: 250 seconds]
bytbox has joined #ocaml
sol__ has joined #ocaml
milosn has quit [Ping timeout: 258 seconds]
eyyub1 has quit [Ping timeout: 265 seconds]
yomimono has joined #ocaml
bytbox has quit [Remote host closed the connection]
ollehar has quit [Ping timeout: 264 seconds]
<hugomg> Is there a way to aboid writing the "fallback ()" bit twice in this code: http://pastebin.com/r3Hnpnhm ?
<hugomg> In an imperative language I would have used "return" / "goto" got that.
ollehar has joined #ocaml
bytbox has joined #ocaml
<ggole> A guarded match?
<ggole> Although that would execute the function unconditionally, which might not be what you want.
<hugomg> yeah, ideally I would not like to move frobnicate out of the loop
ollehar has quit [Ping timeout: 245 seconds]
<ggole> You could pull both tests into a function that returns an option
<ggole> Seems just as heavy when the parts are simple though.
slash^ has joined #ocaml
<Kakadu> I think that && will work
<Kakadu> or not?
<ggole> You can't bind x in the right hand of &&
<ggole> You'd have to be able to write something like
<ggole> uh
<ggole> if frobnicatable && frob_ok (frobnicate () as x) then x else fallback ()
<Kakadu> if true && (let x = 5 in (x>0)) then 1 else 0;;
bytbox has quit [Remote host closed the connection]
<ggole> If that worked, you could just write if frobnicatable && frob_ok (frobnicate () then ... else fallback ()
<ggole> But it is desired to bind x (so that it can be returned)
<Kakadu> ah, OK
ygrek has quit [Ping timeout: 250 seconds]
kalzz has quit [Ping timeout: 260 seconds]
tharugrim has quit [Ping timeout: 258 seconds]
tharugrim has joined #ocaml
bytbox has joined #ocaml
milosn has joined #ocaml
bytbox has quit [Remote host closed the connection]
ygrek has joined #ocaml
Kakadu has quit [Quit: Page closed]
kalzz has joined #ocaml
Hannibal_Smith has joined #ocaml
manizzle has quit [Ping timeout: 264 seconds]
thomasga1 has joined #ocaml
jwatzman|work has joined #ocaml
thomasga1 has quit [Client Quit]
chambart has quit [Ping timeout: 252 seconds]
travisbrady has joined #ocaml
Anarchos has joined #ocaml
jao has joined #ocaml
jao has quit [Changing host]
jao has joined #ocaml
ygrek has quit [Ping timeout: 272 seconds]
ingsoc has quit [Quit: Leaving.]
davine has quit [Ping timeout: 240 seconds]
jao has quit [Remote host closed the connection]
ingsoc has joined #ocaml
keen__________ has joined #ocaml
jonludlam has quit [Quit: Coyote finally caught me]
keen_________ has quit [Ping timeout: 250 seconds]
psy_ has quit [Quit: Leaving]
Hannibal_Smith has quit [Quit: Leaving]
thegameg has joined #ocaml
jao has joined #ocaml
jao has quit [Changing host]
jao has joined #ocaml
psy_ has joined #ocaml
kakadu_ has joined #ocaml
oscar_toro has quit [Ping timeout: 255 seconds]
samuel02 has joined #ocaml
davine has joined #ocaml
samuel02 has quit [Remote host closed the connection]
alkoma has joined #ocaml
WraithM has joined #ocaml
ingsoc has quit [Quit: Leaving.]
MrScout has joined #ocaml
alkoma has left #ocaml [#ocaml]
axiles has quit [Quit: Quitte]
manizzle has joined #ocaml
davine has quit [Quit: Leaving]
manizzle has quit [Remote host closed the connection]
manizzle has joined #ocaml
jabesed has quit [Quit: Konversation terminated!]
travisbrady has quit [Quit: travisbrady]
manud has joined #ocaml
<seliopou> I'm trying to load a camlp4 lexer module into utop to check out the types, but I keep getting parse errors even though I've loaded camlp4o (using #camlp4o)
<seliopou> anybody tried this before and have any pointers?
samuel02 has joined #ocaml
WraithM_ has joined #ocaml
<whitequark> what error exactly do you get?
<seliopou> a random parse error
<seliopou> expecting semilicon but found something else
oscar_toro has joined #ocaml
<seliopou> Error: Parse error: ";" or ":" or ":>" or ")" expected after [expr] (in [expr])
<whitequark> and what is your input?
<seliopou> I'm just trying to load the module in utop
<seliopou> I'm not giving the lexer itself any input
<whitequark> wait, what exactly is a camlp4 lexer module?
<seliopou> it's just some code that implements the lexer
manud has quit [Quit: Be back later ...]
<ggole> Hmm, trace compilers are fun until you get to side exits :/
<whitequark> so you're trying to replace the OCaml lexer? or what?
<seliopou> I have a file that implements this interface: http://camlunity.ru/doc/camlp4-3.12/Camlp4.Sig.Lexer.html
<seliopou> i'm just trying to load that into utop so I can poke around
<seliopou> but I'm getting parse errors when I try to load it
<whitequark> what exactly is in this file and where does the error point to?
<whitequark> you're making it hard to help you.
<seliopou> o_O
samrat has quit [Quit: Computer has gone to sleep.]
<whitequark> oh
<whitequark> it uses ulex syntax. you need to load ulex's camlp4 extension first
<whitequark> so... #require "ulex" should do
<seliopou> thanks
<whitequark> it would not be possible to answer this question without actually seeing the source. I didn't ask for it out of idle curiosity. so, please take note
yomimono has quit [Ping timeout: 265 seconds]
<seliopou> whitequark: it was a misunderstanding of the term "input"
<seliopou> please take note
<whitequark> sigh
<seliopou> what
<seliopou> what's not understandable?
<seliopou> that*
<seliopou> rather
<whitequark> I mean you really should provide the error and the context for it, which in this case the full toplevel output and the source it barfs on.
chinglish has quit [Quit: Nettalk6 - www.ntalk.de]
<seliopou> from your perspective you were asking for the file that implemented the syntax extension, from my perspective you were asking for the file that used the syntax extension
<whitequark> ok, sorry for being harsh
<seliopou> it's ok, thank you for your help
bytbox has joined #ocaml
larhat has joined #ocaml
MrScout_ has joined #ocaml
MrScout has quit [Ping timeout: 255 seconds]
travisbrady has joined #ocaml
MrScout_ has quit [Ping timeout: 244 seconds]
Intensity has joined #ocaml
Intensity has quit [Changing host]
Intensity has joined #ocaml
slash^ has quit [Read error: Connection reset by peer]
travisbrady has quit [Client Quit]
eyyub1 has joined #ocaml
travisbrady has joined #ocaml
Submarine has joined #ocaml
kakadu__ has joined #ocaml
kakadu__ has quit [Client Quit]
Kakadu has joined #ocaml
zozozo has quit [Ping timeout: 260 seconds]
nicoo has quit [Ping timeout: 250 seconds]
nicoo has joined #ocaml
Kakadu has quit [Client Quit]
Kakadu has joined #ocaml
Kakadu has quit [Client Quit]
Kakadu has joined #ocaml
<struktured> companion_cube: how would you use CCSequence to make an infinite sequence of the natural numbers? I tried using a stateful function with a counter to build the sequence but some sequence operations became inconsistent (such as head)
<whitequark> I think you need gen for that
<whitequark> in unrelated news, why does Lexer have a poor reimplementation of Buffer? O_o
shinnya has quit [Ping timeout: 264 seconds]
<ggole> In the stdlib?
<whitequark> not Lexing. Lexer, the OCaml lexer from compiler-libs
<struktured> whitequark: sounds like what I want. is that a cc module?
<whitequark> separate package
<ggole> Lexing has about half of Buffer, too
<ggole> (Although I don't think Buffer exposes enough bits to be used there.)
<whitequark> it's literally just Buffer
<ggole> It... is, isn't it?
<ggole> And it's not a very good implementation :/
<whitequark> exactly my point
rgrinberg has joined #ocaml
<whitequark> also, Parsing is not reentrant
<whitequark> really, much of ocamlc needs to be cleansed with fire
<whitequark> #ForkOCaml
<ggole> Heh
<ggole> iocaml, anybody?
<whitequark> iocaml?
<whitequark> isn't that the ipython thing?
<ggole> Referencing that silly io.js fork of node
travisbrady has quit [Quit: travisbrady]
<whitequark> oh
Anarchos has quit [Ping timeout: 272 seconds]
hugomg has quit [Ping timeout: 260 seconds]
manud has joined #ocaml
* ggole wonders (again) what a cleaned-up ocaml would look like
<whitequark> i wouldn't touch the language, rather the compiler and stdlib to make it easier to work with
<whitequark> compiler-libs is such a great idea, NOW MAKE IT USABLE OKAY
<whitequark> SAY NO TO GLOBAL STATE #ANARCHY
<mrvn> kill ocamls global state so I can run two runtimes.
<whitequark> no, I'm talking about ocamlc, not ocamlrun
<mrvn> I'm talking about ocamlopt output
<whitequark> it's a perf hit if you don't have enough registers
<whitequark> on ARM I think you actually do
<ggole> For TLS?
<mrvn> arm has a user writable thread register.
<whitequark> yeah
<whitequark> I mean, on ARM it already puts all the state in registers
<whitequark> trap_ptr, alloc_ptr, alloc_limit
<mrvn> whitequark: you have some global locks/mutexes
Hannibal_Smith has joined #ocaml
<whitequark> that's not in ocamlopt output though
<whitequark> that's in ocamlrun.
<mrvn> it's in the runtime lib
<whitequark> libcamlrun, yeah
Kakadu has quit [Remote host closed the connection]
Kakadu has joined #ocaml
<whitequark> although, even on ARM there are some more globals
oscar_toro has quit [Read error: Connection reset by peer]
<whitequark> but those aren't hot, so they can be moved into TLS painlessly
<ggole> It's a good argument for having tons of registers
<ggole> 6 was a bit on the low side.
<mrvn> not realy. all you need is one
<mrvn> 6 is a joke
<ggole> Didn't really hurt x86 though.
<mrvn> ggole: x86 majorly hurts from lack of registers.
<ggole> And yet x86 stomped everything which had tons of registers.
<ggole> (Partly because Intel was forced to make memory fast, which turns out to be pretty important.)
<mrvn> It's the reason that amd64 is generally up to 30% faster despite the larger memory footprint and code size. More registers.
<whitequark> success is not an argument for or against technical quality
oscar_toro has joined #ocaml
<whitequark> by this measure, PHP and Java are so much better than OCaml ;p
<ggole> But x86 wasn't all that slow compared to the competition
<ggole> Except for *much* more expensive machines, which it ended up eating from below anyway.
<whitequark> performance, power consumption, silicon area
<whitequark> pick two
<mrvn> ggole: x86 didn't even have fast memory. A Pentium 90 gets ~35MB/s. Same memory in an Amiga 68060 50MHz gets 66MB/s.
thegameg has quit [Remote host closed the connection]
<ggole> It got reorder buffers and call prediction stacks and other tricks to make memory accesses (seem) fast.
thegameg has joined #ocaml
<whitequark> or to put it another way: you need Intel to make x86 look fast
<ousado> whitequark: it'll be interesting to see what the Mill architecture makes of that statement
<whitequark> or, you can design a sane core and have how many orders of magnitude less engineers?
<mrvn> x86 just plain sucks all around. Nobody is using that for speed.
<ggole> Intel do have an overengineering problem.
<whitequark> ousado: I've looked at Mill for hours and I still don't really see any benefits from using it
<ggole> See IA64.
mort___ has joined #ocaml
<whitequark> isn't it kind of VLIW from another angle?
<ousado> whitequark: have you seen the talks? I think that's quite compelling
rgrinberg has quit [Quit: Leaving.]
<ggole> Sort of, yeah
<whitequark> I can't grok information from talking heads, so no
<whitequark> I only read about it
<ggole> You had packets of independent instructions, and they had tags indicating whether the next packet depended on the current one.
<ggole> The idea was that (without changing the ISA) more aggressive future CPUs could execute more packets in parallel.
<whitequark> um. don't CPUs already do that on existing ISAs?
<ggole> Not x86, it's all done dynamically there.
<ggole> Which turns out to be the better idea, I think.
<ousado> I don't know much about chip design, but unless the guy didn'tblatantly lie, the Mill architecture solves a number of issues that make x86 and amd64 problematic
<whitequark> ah, got it
<ggole> Because dynamic IP turns out to be considerable, and static methods just miss out.
jonludlam has joined #ocaml
bytbox has quit [Ping timeout: 258 seconds]
<ggole> IA64 had some interesting stuff though.
<ggole> They had speculative loads in software.
<ggole> You could emit a load, and then N instructions later there would be a verification.
<ousado> err *did :/
<mrvn> that's called prefetch in other cpus.
rgrinberg has joined #ocaml
<ggole> It isn't prefetch.
<ggole> The idea isn't to fetch data ahead of time, it's to try to avoid aliasing issues by speculating that they don't happen.
<ggole> You issue a speculative load, and if something else clobbers it you fail the verification.
matason has quit [Quit: Leaving...]
bytbox has joined #ocaml
rgrinberg has quit [Quit: Leaving.]
Hannibal_Smith has quit [Quit: Leaving]
lordkryss has joined #ocaml
ggole has quit []
MrScout has joined #ocaml
rgrinberg has joined #ocaml
AlexRussia has quit [Quit: WeeChat 1.1-dev]
AlexRussia has joined #ocaml
AlexRussia has quit [Client Quit]
AlexRussia has joined #ocaml
rgrinberg has quit [Quit: Leaving.]
axiles has joined #ocaml
mort___ has quit [Quit: Leaving.]
rgrinberg has joined #ocaml
arthur__ has joined #ocaml
arthur__ has quit [Client Quit]
bytbox has quit [Remote host closed the connection]
MrScout_ has joined #ocaml
myyst has joined #ocaml
rgrinberg has quit [Quit: Leaving.]
MrScout has quit [Ping timeout: 258 seconds]
MrScout_ has quit [Ping timeout: 258 seconds]
MrScout has joined #ocaml
rgrinberg has joined #ocaml
lupine has joined #ocaml
olauzon has quit [Quit: olauzon]
rgrinberg has quit [Quit: Leaving.]
eyyub1 has quit [Ping timeout: 245 seconds]
samuel02 has quit [Remote host closed the connection]
lu324_ has joined #ocaml
lu324 has quit [Ping timeout: 240 seconds]
eyyub1 has joined #ocaml
Arsenik has joined #ocaml
travisbrady has joined #ocaml
_JokerDoom has joined #ocaml
BitPuffin has quit [Ping timeout: 258 seconds]
JokerDoom has quit [Ping timeout: 252 seconds]
kakadu_ has quit [Quit: Page closed]
Kakadu has quit [Remote host closed the connection]
zozozo has joined #ocaml
WraithM has quit [Quit: leaving]
WraithM_ is now known as WraithM
dmiles has joined #ocaml
travisbrady has quit [Quit: travisbrady]
dmiles_afk has quit [Ping timeout: 244 seconds]
<companion_cube> struktured: Sequence.(1 -- max_int) should do ^^
<companion_cube> you can write it with a reference, but be careful to create a neew reference each time the sequence is called
<companion_cube> (traversed)
pdewacht has quit [Ping timeout: 256 seconds]
pdewacht has joined #ocaml
claudiuc has joined #ocaml
<companion_cube> (wait, that's not even required)
<companion_cube> let nat k = for i = 0 to max_int to k i done
jao has quit [Ping timeout: 258 seconds]
larhat has quit [Quit: Leaving.]
ollehar has joined #ocaml
ollehar has quit [Client Quit]
bitbckt has quit [K-Lined]
eyyub2 has joined #ocaml
bitbckt has joined #ocaml
bitbckt has quit [Changing host]
bitbckt has joined #ocaml
samuel02 has joined #ocaml
demonimin has quit [Remote host closed the connection]
eyyub1 has quit [Ping timeout: 250 seconds]
rgrinberg has joined #ocaml
<struktured> companion_cube: sorry think I'm riding the gen train. thanks for the response though :)
<companion_cube> that can work too
<companion_cube> Gen.(1 -- max_int)
demonimin has joined #ocaml
<struktured> that syntax is pretty wild. assumin -- is a range operator ?
<companion_cube> yes
<companion_cube> there is a range function if you prefer
<companion_cube> Gen.(1 -- max_int |> take 10 |> to_list);;
manud has quit [Quit: Be back later ...]
myyst has quit [Read error: Connection reset by peer]
<struktured> companion_cube: cool, although I hope to take advantage of Gen.init with the function given as an arg too
<companion_cube> note that Gen.t values are consumable
manud has joined #ocaml
myyst has joined #ocaml
<struktured> yeah thats fine
eyyub3 has joined #ocaml
samuel02 has quit [Ping timeout: 245 seconds]
<Drup> MercurialAlchemi: I have a slightly different view than companion_cube on "where to use gen/sequence"
<Drup> It's personally "gen when I want to stream, sequence when I want to do one shot iterator really fast"
<companion_cube> it's personnally mostly Sequence because it's so fast
manud has quit [Quit: Be back later ...]
eyyub2 has quit [Ping timeout: 258 seconds]
<Drup> except when streaming :p
<companion_cube> sure
Arsenik has quit [Remote host closed the connection]
<companion_cube> Gen is a good replacement to Stream, I think
<companion_cube> for parsers, etc. it's ok
<companion_cube> it could even be extended to be monadic
<companion_cube> c'est quelle license sedlex, en pasant ?
<companion_cube> +s
<Drup> companion_cube: that was very difficult to find: https://github.com/alainfrisch/sedlex/blob/master/LICENSE
<companion_cube> I have a slow computer, much easier to ask you :p
<companion_cube> I'm a bit surprised actually that opam doesn't list the license
<companion_cube> ah, MIT, neat
def`1 has joined #ocaml
def`1 has quit [Client Quit]
Simn has quit [Quit: Leaving]
<lupine> 'We use Github to store all the comments recorded against book milestones instead of keeping our own database'
* lupine dies a little inside
<Drup> why ?
<Drup> comments are arguably bug reports in this context
rgrinberg has quit [Quit: Leaving.]
<lupine> storing all the datas in github makes me sad, is all
<Drup> having real bug reports opened for each of them doesn't seem like a terrible idea, and iirc, that's exactly what they do
araujo has quit [Ping timeout: 240 seconds]
rgrinberg has joined #ocaml
<lupine> the system is arguably eminently sensible
WraithM has quit [Quit: leaving]
<whitequark> not sure what's the issue with storing data in github
<Drup> (you can argue that it should be inside a custom gitlab, or something like that, but you could then say that about the whole github)
<lupine> I typically do ^^
<Drup> right, so then I don't disagree :)
<whitequark> you can export it with one line in shell, and it's arguably less likely to die than your own server
<lupine> strokes, folks, the usual
<companion_cube> I' still a bit uneasy using github issues, because it's really tying oneself to github
<whitequark> File "_none_", line 1:
<whitequark> Error: Unbound value lexbuf
<whitequark> ugh, sedlex.
<companion_cube> (whereas just using the git repo is fine)
rand000 has quit [Quit: leaving]
<Drup> companion_cube: you can get them by one cli call :>
<companion_cube> and then, what to make of it?
<Drup> that's another issue, but you can fetch them
<companion_cube> yes
<whitequark> it's a trivially readable JSON file
<Drup> (in ocaml, of course :D)
<whitequark> export it to gitlab or whatever
<whitequark> even to text documents, if you so wish
<companion_cube> oh, if gitlab can read it...
<whitequark> I don't know if it can, but making it so it could is trivial
<companion_cube> still no idea what the business model of github is supposed to be...
<companion_cube> Drup: sure :p
<companion_cube> so, g@sche convinced me to spend a bit of time to help him on batteries
<whitequark> g@sche?
<companion_cube> don't want to disturb him :p
<Drup> such delicate non-hl
<lupine> I think they offer private hosted instances
<whitequark> reminds me of micro$oft
<Drup> stealthy as fuck.
<companion_cube> I might also split containers into smaller chunks, for instance CCIO and CCSexpr into containers.io
<lupine> we've recently got a new hire who is very big on using github for everything. meanwhile, the rest of us sit grumpily on our redmine install, muttering away
MrScout has quit [Remote host closed the connection]
<whitequark> redmine is fairly user-hostile
MrScout has joined #ocaml
<lupine> can't disagree
<whitequark> be glad you're not on JIRA
<lupine> it's also very deployment-hostile
<lupine> ruby, eh
<whitequark> yeah, I've both used and administered it
<whitequark> though it was at 1.8 times
<companion_cube> whitequark: did you use the clonable generator in the end?
<whitequark> companion_cube: nope
<companion_cube> erf
<companion_cube> might move that to its own module
MrScout has quit [Ping timeout: 258 seconds]
<whitequark> I still want an exposed MList
<whitequark> my current Restart-heavy solution is inefficient
<companion_cube> oh, right, MList
<companion_cube> the current module does expose MList
<whitequark> hmmm
<companion_cube> if you pin the master branch
<whitequark> how do I use it though?
<companion_cube> let mlist = Gen.MList.of_gen_lazy (uutf_read_unicode source...)
<companion_cube> let gen = Gen.MList.to_clonable mlist;;
<companion_cube> let gen' = gen#clone in ... (* use gen *); (* use gen' for backtracking *)
<whitequark> objects O.o
<companion_cube> well, yes, a bit
<companion_cube> do you object to objects?
<whitequark> haha
oscar_toro has quit [Ping timeout: 245 seconds]
<whitequark> not really
PM has quit [Ping timeout: 258 seconds]
chambart has joined #ocaml
<companion_cube> well it's very basic objects here
<companion_cube> o/ chambart
<whitequark> enums
<whitequark> sigh
<whitequark> how can I prepend a singleton to a clonable gen?
<companion_cube> right, I should rename this
<companion_cube> hmm, prepend
<companion_cube> like unget() ?
<whitequark> essentially