NoNNaN has quit [Remote host closed the connection]
ygrek has joined #ocaml
NoNNaN has joined #ocaml
Submarine has joined #ocaml
nojb has joined #ocaml
nojb has quit [Client Quit]
bytbox has quit [Remote host closed the connection]
cesar has joined #ocaml
cesar is now known as Guest77267
shinnya has quit [Ping timeout: 265 seconds]
Guest77267 has quit [Ping timeout: 255 seconds]
<Drup>
| "(" -> LParen"
<Drup>
it works best when it's L and not R, funny =')
avsm has joined #ocaml
waneck has quit [Remote host closed the connection]
avsm has quit [Ping timeout: 240 seconds]
dsheets has quit [Ping timeout: 240 seconds]
Simn has quit [Quit: Leaving]
samuel02 has joined #ocaml
ygrek has quit [Ping timeout: 250 seconds]
<Drup>
whitequark: the new version of the code is mostly finished, but there are errors in the codegen module
<Drup>
I barely touched at this module, we will need to redo it anyway
samuel02 has quit [Ping timeout: 244 seconds]
manizzle has quit [Ping timeout: 244 seconds]
nojb has joined #ocaml
avsm has joined #ocaml
<Drup>
It hurts me to do a tutorial designing a language where the only type is double, including for boolean expressions, though.
ygrek has joined #ocaml
manizzle has joined #ocaml
dsheets has joined #ocaml
WraithM has joined #ocaml
q66[lap] has quit [Read error: Connection reset by peer]
q66[lap]_ has joined #ocaml
MrScout_ has joined #ocaml
MrScout has quit [Ping timeout: 272 seconds]
MrScout_ has quit [Ping timeout: 244 seconds]
travisbrady has joined #ocaml
AlexRussia has quit [Quit: WeeChat 1.1-dev]
manizzle has quit [Ping timeout: 264 seconds]
claudiuc has quit [Remote host closed the connection]
teiresias has quit [Ping timeout: 256 seconds]
nojb has quit [Quit: nojb]
teiresias has joined #ocaml
teiresias has quit [Changing host]
teiresias has joined #ocaml
q66 has quit [Quit: Leaving]
AlexRussia has joined #ocaml
q66[lap]_ has quit [Read error: Connection reset by peer]
q66[lap] has joined #ocaml
hausdorff has quit [Remote host closed the connection]
dsheets has quit [Ping timeout: 265 seconds]
avsm has quit [Quit: Leaving.]
BitPuffin has quit [Ping timeout: 244 seconds]
<Drup>
AltGr: update the 4.02 branch, so I can try :]
larhat has quit [Ping timeout: 245 seconds]
larhat has joined #ocaml
jcloud has quit []
jcloud has joined #ocaml
bytbox has joined #ocaml
hausdorff has joined #ocaml
hausdorff has quit [Ping timeout: 265 seconds]
<struktured>
in 4.02.1 is "bytes" a preferred type over "string"?
<Drup>
bytes are for things you want to mutates, strings not
<struktured>
Drup: really? damn
<struktured>
I definitely changed m y types in the wrong direction then
hausdorff has joined #ocaml
samuel02 has joined #ocaml
NoNNaN has quit [Ping timeout: 250 seconds]
<struktured>
Drup: so..still a little confused. why the does type system seem so indifferent to my choice of bytes vs string then?
<Drup>
because you didn't pass -safe-string to the compiler
<Drup>
if you don't, byte=string
<struktured>
Drup: that's what I needed to know! turning that on
NoNNaN has joined #ocaml
samuel02 has quit [Ping timeout: 245 seconds]
badkins has quit []
hausdorff has quit [Remote host closed the connection]
<AltGr>
Drup, done
<Drup>
still not working :/
dmiles_afk has joined #ocaml
manizzle has joined #ocaml
samrat has joined #ocaml
Submarine has quit [Remote host closed the connection]
hausdorff has joined #ocaml
larhat1 has joined #ocaml
larhat has quit [Ping timeout: 255 seconds]
Cypi has quit [Ping timeout: 255 seconds]
Cypi has joined #ocaml
hcarty has quit [Ping timeout: 265 seconds]
hcarty has joined #ocaml
jao has quit [Ping timeout: 255 seconds]
wormphlegm has quit [Ping timeout: 244 seconds]
<Drup>
AltGr: the difference, I presume, is that in 4.01, Atom is a copy of Syndic_atom while in 4.02 it's a module alias, hence not pulled except if needed
<Drup>
or something like that
wormphlegm has joined #ocaml
<AltGr>
aah, _these_ module aliases
<AltGr>
of course
<AltGr>
actually they should make things better for indexing
<Drup>
ah, the delight of overloaded idioms :p
<AltGr>
(preserving locations, for example, would have been quite difficult before)
travisbrady has quit [Quit: travisbrady]
manizzle has quit [Quit: Leaving]
manizzle has joined #ocaml
<Drup>
the fact that libIndex traverses signature functors makes things *much* better with tyxml/eliom
<Drup>
AltGr: I will let you hunt module aliases and go to bed ;)
<AltGr>
:)
<AltGr>
we get lots more positions than we could with 4.01 too
kdef has joined #ocaml
manud has quit [Quit: Be back later ...]
Submarine has joined #ocaml
bytbox has quit [Remote host closed the connection]
cesar has joined #ocaml
cesar is now known as Guest61293
Guest61293 has quit [Ping timeout: 256 seconds]
siddharthv_away is now known as siddharthv
manud has joined #ocaml
samrat has quit [Quit: Computer has gone to sleep.]
<whitequark>
companion_cube: yeah, could be useful
<whitequark>
companion_cube: can you open an issue and describe the naming conventions you want and maybe anything else? I will do it then
mcc has joined #ocaml
cesar has joined #ocaml
cesar is now known as Guest78467
demonimin_ has quit [Ping timeout: 244 seconds]
ggole has joined #ocaml
ggole has quit [Read error: Connection reset by peer]
samrat has joined #ocaml
<mcc>
so i feel like if i just put a directory in my ml source folder named "Builtins" and put a "scope.ml" file in it, the ml in my toplevel folder, if I say Builtins.Scope.something will probably treat the Builtins folder as a module and look inside it.
<mcc>
Is this a good assumption or a bad assumption
<mcc>
this is how other languages seem to get designed
<whitequark>
no, it won't
Guest78467 has quit [Remote host closed the connection]
<whitequark>
it'll just be "Scope"
ggole has joined #ocaml
<mcc>
'k
<mcc>
is there a way to do that other than making a really long file with lots of "module" directives in it
<whitequark>
no
<mcc>
'k
MercurialAlchemi has joined #ocaml
natrium1970 has joined #ocaml
<struktured>
regarding this string /bytes thing..is there any way to make merlin treat them strictly?
<whitequark>
ocamlmerling -safe-string
<ygrek>
ocamlzerling
<AltGr>
Drup, works even on Core.Std now with module aliases :)
samuel02 has joined #ocaml
<mcc>
in a vague sense, what are the runtime costs of adding more items to a tagged union?
<struktured>
whitequark: thanks
ygrek has quit [Ping timeout: 245 seconds]
manud has joined #ocaml
samuel02 has quit [Remote host closed the connection]
natrium1970 has quit [Quit: natrium1970]
WraithM has quit [Quit: leaving]
vbmithr has quit [Quit: leaving]
<ggole>
mcc: you mean, changing type t = A | B to type t = A | B | C?
<mcc>
yeah, and i'm particularly curious if this is implemented in a way the B or C being "of" some more complex type like a record has consequences for the A
<mcc>
or if this is a thing i need to think about
<ggole>
Matching on a data type is "constant time"
<mcc>
'k
<mcc>
does the type of C have memory implications if i make lots and lots and lots of As or Bs?
<ggole>
In practice there will be a small cost for each constructor up until a certain bound, at which point the compiler will switch from using branches to jump tables and things will flatten out.
<ggole>
No.
<mcc>
huh, interesting
<ggole>
The representation of A and B are entirely unaffected.
<mcc>
cool
_5kg has quit [Ping timeout: 256 seconds]
<ggole>
OCaml has a pretty simple representation scheme in which nullary constructors are ints, and constructors with arguments are a pointer to an allocated block (which is prefixed by a tag indicating the constructor)
<ggole>
There's a good chapter on this in real world ocaml if you are interested in the details.
<mcc>
cool
<mcc>
i'm working myself through that fitflly
<whitequark>
you can't have more than 240 or so constructors with parameters though
<whitequark>
it's a bit silly
<mcc>
"can't" or "shouldn't"
<whitequark>
can't
<mcc>
'k
<whitequark>
the tag is only so wide
<ggole>
They could fix that if anybody cared.
<ggole>
(At a minor cost.)
<whitequark>
yep
<MercurialAlchemi>
can't imagine why you'd want so many constructors
<whitequark>
autogenerated code
<MercurialAlchemi>
outside of generated code
<MercurialAlchemi>
:)
<MercurialAlchemi>
but then, you may be able to hierarchise
<MercurialAlchemi>
it's a bit ugly, but we're talking about generated code
<adrien>
240 is not much
<adrien>
it's like the MAX_PATH limit
<adrien>
why would you want paths that are longer than that? :P
<MercurialAlchemi>
well, how often do you want something bigger than 240?
ygrek has joined #ocaml
<adrien>
not that often but the limit isn't very high and it's quite easy to reach it
<adrien>
btw, installed VS community edition on yesterday
<adrien>
new project -> "F# tutorial"
<MercurialAlchemi>
:)
<adrien>
670 lines of commented code
<adrien>
that's it
<adrien>
and they show 20 "concepts" in these
keen___________2 has joined #ocaml
<adrien>
I have no idea how that'd help anyone
<whitequark>
adrien: what.
<whitequark>
MAX_PATH shouldn't exist at all.
keen___________1 has quit [Ping timeout: 255 seconds]
<whitequark>
not to mention that if you're using, say, russian, those 240 bytes are 80 characters
<adrien>
well, on windows if you use unicode functions you don't have MAX_PATH (there's another limit but it's several thousands if not tens of thousands and counting in unicode chars)
<adrien>
don't remember which one on linux still have MAX_PATH
seliopou has quit [Ping timeout: 258 seconds]
<whitequark>
they all do, but MAX_PATH is rather large in practice
<whitequark>
4096?
<adrien>
don't find it again in my /usr/include/
<whitequark>
it's PATH_MAX
<adrien>
ah, right, thanks :]
<adrien>
too early in the morning :p
<adrien>
MAX_PATH is the windows one
<whitequark>
/usr/include/linux/limits.h:#define PATH_MAX 4096 /* # chars in a path name including nul */
<adrien>
realpath() uses itand that might well be one of the few that does
<adrien>
probably because it _returns_ something
<MercurialAlchemi>
"nobody needs more than 640k of RAM"
seliopou has joined #ocaml
<whitequark>
you do realize Gates never said that?
<MercurialAlchemi>
since that's not much ram at all, it follows logically that you don't need more than 240 quantities of anything to store in that ram
<MercurialAlchemi>
yes
<MercurialAlchemi>
but it's a funny quote
<adrien>
but reading realpath's manpage again, it's clear the function is completely broken
<adrien>
buffer is small and can't be made large since you can't pass a "length" argument to the function
<MercurialAlchemi>
it endures for a reason
<MercurialAlchemi>
not that you could a single OCaml executable in so little RAM
* MercurialAlchemi
groans
<MercurialAlchemi>
"that you could load", even
samuel02 has joined #ocaml
samuel02 has quit [Client Quit]
<whitequark>
huh? you could, in fact
<MercurialAlchemi>
with paging?
<whitequark>
why not?
<whitequark>
or do you mean "using swap"?
<MercurialAlchemi>
I'd rather have smaller binaries
<whitequark>
I mean, if you count in libc, libm, libdl, *and* it's glibc, then obviously not
<whitequark>
but there is nothing in ocaml that prohibits that in principle
<MercurialAlchemi>
right
<adrien>
plus 16 bits
<adrien>
well
<adrien>
that'd be the issue with ocaml :P
<whitequark>
I'd say around 16kb (on a 32-bit arch) would be the requirements for the smallest ocaml program useful at all
<MercurialAlchemi>
for hello world?
<whitequark>
yeah
<MercurialAlchemi>
(whether hello world is useful is subject to debate)
<mcc>
"false" and "true" are useful programs
<whitequark>
mcc: not really much smaller than hello world, assuming you don't DCE GC and the rest of runtime
<mcc>
"echo" with no arguments is useful
<whitequark>
oh, I see your point though
<whitequark>
yes
* mcc
thinks
<mcc>
is it ok to swear in this channel
<whitequark>
people do it :)
* MercurialAlchemi
isn't quite a sure a cocktail of tea, technical discussion and reading about the abortive Finnish monarchy post WWI is the best thing to wake up on
<mcc>
in high school, i was the root administrator on the server run by the high school's linux club
<mcc>
i added executables named "fuck" and "damn" to the path which did nothing but express sorrow that the user had resorted to such anger
<MercurialAlchemi>
haha
<mcc>
after observing that when teenagers are introduced to linux for the first time, when they get frustrated, they tend to type "fuck you" into the prompt
<mcc>
this may qualify as a "useful" program, for some interpretations of the word "useful"
<MercurialAlchemi>
right
<MercurialAlchemi>
well, there are a number of suggestively-named unix utilities
kdef has quit [Remote host closed the connection]
<whitequark>
most of them?
mcc has quit [Quit: sleeeeeeeeep]
<MercurialAlchemi>
not ls
<MercurialAlchemi>
or cd
<adrien>
8:33 ~ % ls /usr/bin | wc -l
<adrien>
3637
<adrien>
8:33 ~ % wc -l /usr/share/dict/words
<adrien>
38619 /usr/share/dict/words
<adrien>
probably because there are so many of them
<adrien>
and because we can find any word subjective
<MercurialAlchemi>
suggestive you mean?
<adrien>
yeah
<adrien>
still too early :)
<MercurialAlchemi>
read more Finnish history, that'll help
<whitequark>
let's start a semantics flamewar based on whether a shell builtin is an "utility"
<MercurialAlchemi>
hm
* MercurialAlchemi
attempts to find a 'utility' command without success
* MercurialAlchemi
concludes his shell doesn't contain any utility
<struktured>
MercurialAlchemi: no command would ever be that long. it would be shorterned to "util" or just "ut"
jonludlam has quit [Quit: Coyote finally caught me]
<MercurialAlchemi>
struktured: you do have longer names for some things
<MercurialAlchemi>
like rsnapshot
<whitequark>
that's not true unix. true unix, aka plan9, has every command named in two letters
<whitequark>
7c, 7l, 7a
<MercurialAlchemi>
by that measure neither cat nor echo are 'true unix'
<ygrek>
of course
<ygrek>
who needs cat when there is dd
<MercurialAlchemi>
that reminds me, I found out about TECO yesterday
<MercurialAlchemi>
an 'editor' which existed before Unix was a twinkle in its authors' eyes
toolslive has joined #ocaml
zpe has joined #ocaml
ikaros has joined #ocaml
<companion_cube>
whitequark: sure, I'll open an issue
vogler has joined #ocaml
jave has quit [Ping timeout: 256 seconds]
_5kg has quit [Ping timeout: 244 seconds]
jave has joined #ocaml
jgjl has joined #ocaml
bezirg has joined #ocaml
larhat1 has quit [Quit: Leaving.]
sgnb has joined #ocaml
govg has quit [Remote host closed the connection]
Simn has joined #ocaml
adrien_o1w has joined #ocaml
adrien_oww has quit [Ping timeout: 256 seconds]
Kakadu has joined #ocaml
ollehar has joined #ocaml
siddharthv is now known as siddharthv_away
q66[lap] has quit [Read error: Connection reset by peer]
q66[lap] has joined #ocaml
_5kg has joined #ocaml
alexherbo2 has quit [Remote host closed the connection]
Submarine has quit [Quit: Leaving]
demonimin has joined #ocaml
jc1 has joined #ocaml
jgjl has quit [Ping timeout: 255 seconds]
<Unhammer>
with Lwt_process.pmap, how can I see the exit status?
<whitequark>
you can't
asmanur_ has quit [Ping timeout: 244 seconds]
hausdorff has quit [Remote host closed the connection]
serge has quit [Ping timeout: 265 seconds]
hausdorff has joined #ocaml
<Unhammer>
hmm. So if I want to send lots of text through sed (for examples sake), I have to manually loop with (write PIPEBUF in_c;read PIPEBUF out_c)
<Unhammer>
I know I haven't reached pipebuf … what am I doing wrong?
<mrvn>
Has anyone tried runnign 2 ocaml runtimes in a single process?
<ygrek>
mrvn, there is patched ocaml for that
siddharthv_away is now known as siddharthv
<mrvn>
from ocamlpro?
sgnb has quit [Remote host closed the connection]
lordkryss_ has joined #ocaml
ygrek has quit [Ping timeout: 240 seconds]
manud has quit [Quit: Be back later ...]
<mrvn>
I found slides by Luca Saiu.
demonimin has quit [Remote host closed the connection]
demonimin has joined #ocaml
jc2 has joined #ocaml
govg has joined #ocaml
jc1 has quit [Ping timeout: 264 seconds]
nojb has joined #ocaml
demonimin has quit [Remote host closed the connection]
dmiles_afk has quit [Quit: Read error: 110 (Connection timed out)]
nojb has quit [Ping timeout: 245 seconds]
dsheets has joined #ocaml
nojb has joined #ocaml
govg has quit [Ping timeout: 272 seconds]
rand000 has joined #ocaml
<toolslive>
actually, what's the status of the "ocaml multi-core" project? have seen a presentation in September where the bytecode version was demoed, but that's about it.
<Unhammer>
huh, copying Lwt_process.pmap and making it return status as well as output was quite easy; seems the Lwt method means it doesn't need to worry about hitting PIPEBUF =D
<Leonidas>
gasche: are you going to publish random-generator on OPAM? Because qcheck dropped it from its 0.3 release, so there is no way to get the package
demonimin has quit [Ping timeout: 244 seconds]
samrat has quit [Quit: Computer has gone to sleep.]
jao has joined #ocaml
jao has quit [Changing host]
jao has joined #ocaml
ohama has quit [Ping timeout: 245 seconds]
_5kg has quit [Ping timeout: 264 seconds]
<companion_cube>
Leonidas: oh, sorry, we should make an opam package
<Leonidas>
companion_cube: yes, just figured out that i can opam pin add random-generator --dev-repo https:// myself. Works fine, but it'd still be neat to have it in the repositories :-)
jc2 has quit [Quit: Leaving.]
axiles has joined #ocaml
<companion_cube>
Leonidas: sure
<companion_cube>
re-splitting random-generator from qcheck is better, imho, because it will allow both to progress at their own pace
adrien_o1w is now known as adrien_oww
hausdorff has joined #ocaml
<Leonidas>
companion_cube: agreed. Actually a splitted out random generator can be useful for my own projects which do not need QCheck.
<mrvn>
libboost1.55-all-dev - Boost C++ Libraries development files (ALL)
<mrvn>
ups
<MercurialAlchemi>
ok
_5kg has joined #ocaml
shinnya has quit [Ping timeout: 244 seconds]
<Unhammer>
in lwt, is there a way to cancel any threads waiting on a certain mutex? (not the one holding the mutex, just the waiters)
<nojb>
Yes, use Lwt.cancel
<nojb>
e.g. if let waiter = Lwt_mutex.lock mutex then you can do Lwt.cancel waiter and it will cancel it.
slash^ has joined #ocaml
<Unhammer>
oh, so need to put all waiters into a ref list … hm
travisbrady has joined #ocaml
BitPuffin has joined #ocaml
serge has joined #ocaml
AlexRussia has quit [Ping timeout: 272 seconds]
Thooms has joined #ocaml
AlexRussia has joined #ocaml
serge has quit [Read error: No route to host]
serge has joined #ocaml
nop0x07bc has joined #ocaml
hausdorff has joined #ocaml
<Unhammer>
I want to have at most one in-progress thread, and at most one "next-in-line", for processing a textarea on keypresses. The next-in-line should always be the most recent. Is http://sprunge.us/SVEi?ocaml a sane way to do it?
<Drup>
you're doing a server check on each key pressed ?
<Drup>
that's ... not a good idea.
hausdorff has quit [Ping timeout: 245 seconds]
<Unhammer>
not every, only the last; and apparantly with that limited_loop I can add a ~delay
<Drup>
oh, I see
<Drup>
what is your goal in limiting one event in the queue ?
<Unhammer>
hmm, how to explain … if the user is editing the text, only the last part is really "valid"
manizzle has joined #ocaml
<Drup>
the last part ?
<Unhammer>
last state of the text
<Drup>
you mean, you only want to check the text once the user stop editing ?
<Unhammer>
not necessarily
<Unhammer>
(though not after *every* keypress, punctuation more likely)
<Drup>
how does limiting the queue achieve that ?
<Unhammer>
it doesn't do that, but it handles the situation where e.g. the user types "foo. bar. fie." in quick succession, and we don't need to send "foo. bar. " if "foo. " is still processing when "foo. bar. fie." is typed
fraggle-boate has quit [Ping timeout: 244 seconds]
<Drup>
I did a buffering system like that once
<Drup>
but can't remember how, and where
travisbrady has quit [Quit: travisbrady]
<Drup>
It's frustrating.
<Unhammer>
heh yeah
travisbrady has joined #ocaml
<Drup>
iirc, the idea was to wait concurrently for a sleep and the action, and refresh the sleep on new actions
samrat has joined #ocaml
govg has joined #ocaml
<Drup>
Unhammer: your thing may work, but I'm pretty sure there is a simpler way to do it =')
fraggle-boate has joined #ocaml
<Unhammer>
somehow I always end up with that feeling when working with threads
<toolslive>
well, part of the problem is that lots of things are called "thread".
badkins has joined #ocaml
bytbox has joined #ocaml
<Leonidas>
companion_cube: how to make an Arbitrary from two Arbitraries? I want to test a function with two parameters. I could wrap it in a tuple, but maybe there's a better way?
cesar_ has joined #ocaml
cesar_ is now known as Guest98224
yomimono has joined #ocaml
fraggle-boate has quit [Ping timeout: 264 seconds]
darkf has quit [Quit: Leaving]
emias has quit [Quit: Reboot.]
ollehar has quit [Ping timeout: 255 seconds]
<mrvn>
Why don't you have a state. If the state is idle you send of the text and set state to busy. If state is busy you change state to dirty. When the processing returns you set and state is dirty you set state to busy and send of the update. If its busy you set it back to idle.
<Drup>
that's pretty much equivalent to a lock.
<mrvn>
nope, no locking there
<Drup>
idle = not taken, busy = taken and no one waiting, dirty = taken and someone waiting
<Drup>
that's the same thing.
<mrvn>
but you don't collect any waiting "threads"
serge has quit [Read error: No route to host]
serge has joined #ocaml
so has quit [Ping timeout: 245 seconds]
fraggle-boate has joined #ocaml
<MercurialAlchemi>
I've done that in raw Javascript
hausdorff has joined #ocaml
<MercurialAlchemi>
not particularly elegant but it works
<MercurialAlchemi>
unless you don't handle errors correctly
emias has joined #ocaml
hausdorff has quit [Ping timeout: 272 seconds]
zpe has quit [Remote host closed the connection]
zpe has joined #ocaml
zpe has quit [Remote host closed the connection]
q66[lap] has quit [Read error: Connection reset by peer]
q66[lap] has joined #ocaml
<Unhammer>
mrvn, that sounds a bit nicer than what I have, thanks :-)
serge has quit []
tane has joined #ocaml
hugomg has joined #ocaml
ikaros has quit [Quit: Ex-Chat]
Guest98224 has quit [Remote host closed the connection]
cesar_ has joined #ocaml
cesar_ is now known as Guest19861
Guest19861 has quit [Ping timeout: 244 seconds]
seanmcl has joined #ocaml
adrien_oww has quit [Quit: et ... disparu !]
MrScout has joined #ocaml
oriba has quit [Quit: Verlassend]
govg has quit [Ping timeout: 240 seconds]
fraggle-boate has quit [Remote host closed the connection]
toolslive has quit [Quit: Leaving]
so has joined #ocaml
badkins has quit [Read error: Connection reset by peer]
<Drup>
whitequark: I have an idea to make the interface menhir/sedlex much nicer. It's slightly cheaty :>
<Drup>
the menhir generated code use the Lexing module
<Drup>
so
<Drup>
we just have overwrite it with a Fake_Lexing modules that uses sedlex :>
pharpend_ has joined #ocaml
Thooms has quit [Quit: WeeChat 1.0.1]
hausdorff has joined #ocaml
thomasga has joined #ocaml
<whitequark>
ew
thomasga has quit [Client Quit]
hausdorff has quit [Ping timeout: 250 seconds]
<Drup>
well, the current situation is quite ridiculous, sedlex and lexing provides as much informations, only in different way ...
nojb has quit [Quit: nojb]
<Drup>
this conversion step shouldn't even exist, and is entirely automatic.
<companion_cube>
Leonidas: I use a tuple in this case
<companion_cube>
any change that UChar gets merged into the compiler?
<Leonidas>
companion_cube: but then you have to pass functions like (fun (x,y) -> prop x y) as properties
<companion_cube>
uncurry prop
<companion_cube>
but yes, that's an inconvenience I don't know how to get rid of
<Leonidas>
companion_cube: I believe cmdliner has an interesting approach
<Leonidas>
it has a specification dsl for arguments (or in the case of QChech arbitraries) and through some trickery it expects a function with the proper arity and types.
<Leonidas>
also, I haven't figured out how it works and it is tricky to use
<Leonidas>
uncurry
<companion_cube>
it doesn't sound easy, because you would have to deal with several generators, printers, etc.
<Leonidas>
sorry (#ocaml is not utop, apparently)
zpe has joined #ocaml
<companion_cube>
:D
<companion_cube>
you have to write it though (fun f (x,y) -> f x y)
manizzle has quit [Ping timeout: 250 seconds]
<Leonidas>
I wonder if it is possible to write an uncurry that does that for n-ary tuples
<Leonidas>
there's surely some nifty trick
zpe has quit [Ping timeout: 245 seconds]
<companion_cube>
I don't think so, you can't do anything generic for tuples of different arities
<ggole>
I can imagine a type system that does that
<ggole>
But that would not be OCaml's
<Leonidas>
a pity
<Leonidas>
though I was quite surprised with what cmdliner does, I need to figure out how that works to learn a trick or two or +\infty
hausdorff has joined #ocaml
<ggole>
It'd be nice to be able to write variadic functions
<ggole>
Probably not worth the complexity
<ggole>
But nice
<Drup>
you can do it with gadts :D
<Drup>
companion_cube: about UChar, tbh, that would surprise me.
<Drup>
but I tend to be overly pessimistic with inclusions in OCaml.
lordkryss_ has quit [Quit: Connection closed for inactivity]
travisbrady has quit [Quit: travisbrady]
bytbox has quit [Remote host closed the connection]
Kakadu has quit [Quit: Page closed]
cesar_ has joined #ocaml
cesar_ is now known as Guest87998
jonludlam has quit [Ping timeout: 264 seconds]
jwatzman|work has joined #ocaml
Guest87998 has quit [Ping timeout: 264 seconds]
travisbrady has joined #ocaml
<companion_cube>
too bad, for a module with a single type :/
tane has quit [Quit: Verlassend]
badkins has joined #ocaml
q66 has joined #ocaml
vogler has quit [Ping timeout: 265 seconds]
ygrek has quit [Ping timeout: 255 seconds]
Kakadu has joined #ocaml
yomimono has quit [Ping timeout: 240 seconds]
manizzle has joined #ocaml
nojb has joined #ocaml
manizzle has quit [Max SendQ exceeded]
manizzle has joined #ocaml
struktured has quit [Ping timeout: 265 seconds]
dsheets has quit [Ping timeout: 264 seconds]
travisbrady has quit [Quit: travisbrady]
nojb has quit [Quit: nojb]
nojb has joined #ocaml
kakadu_ has joined #ocaml
travisbrady has joined #ocaml
BitPuffin has quit [Ping timeout: 272 seconds]
manizzle has quit [Ping timeout: 240 seconds]
manizzle has joined #ocaml
WraithM has joined #ocaml
AlexRussia has quit [Quit: WeeChat 1.1-dev]
AlexRussia has joined #ocaml
MercurialAlchemi has quit [Remote host closed the connection]