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
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?
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.)
<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>
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