sz0 has quit [Quit: My computer has gone to sleep. ZZZzzz…]
dsheets has joined #ocaml
dsheets has quit [Ping timeout: 240 seconds]
Reshi has quit [Ping timeout: 240 seconds]
sh0t has joined #ocaml
dsheets has joined #ocaml
wolfcore has quit [Ping timeout: 246 seconds]
dsheets has quit [Ping timeout: 244 seconds]
Emmanuel`_ has joined #ocaml
hxegon has quit [Ping timeout: 240 seconds]
wolfcore has joined #ocaml
<please_help>
flux: "unless you want to use GPU acceleration", well you're not going to be any ML without it. RL or PC perhaps. Opencl ports of existing libraries also show a lot of performance issues compared to the cuda (main) variant, though that could be due to low interest and thus little manpower. The lack of a cudnn for opencl is definitely an issue on that front, though., companion_cube: tensor_flow has a C interface (though
<please_help>
immature), and there's mxnet/cxxnet, although I don't think they support symbolic or automatic differentiation, which are (at least in my opinion) kind of a big deal.
yunxing_ has quit [Remote host closed the connection]
shinnya has quit [Ping timeout: 244 seconds]
ygrek has quit [Ping timeout: 252 seconds]
dsheets has joined #ocaml
dsheets has quit [Ping timeout: 268 seconds]
FreeBirdLjj has joined #ocaml
FreeBirdLjj has quit [Remote host closed the connection]
FreeBirdLjj has joined #ocaml
Emmanuel`_ has quit [Quit: Konversation terminated!]
Emmanuel`_ has joined #ocaml
yunxing has joined #ocaml
Reshi has joined #ocaml
tennix has quit [Ping timeout: 264 seconds]
antkong has quit [Quit: antkong]
hxegon has joined #ocaml
dsheets has joined #ocaml
dsheets has quit [Ping timeout: 260 seconds]
antkong has joined #ocaml
dsheets has joined #ocaml
Mandus has quit [Ping timeout: 244 seconds]
kushal has joined #ocaml
dsheets has quit [Ping timeout: 250 seconds]
tennix has joined #ocaml
Emmanuel`_ has quit [Quit: Konversation terminated!]
Emmanuel`_ has joined #ocaml
cnu- has quit [Ping timeout: 268 seconds]
Emmanuel`_ has quit [Client Quit]
Emmanuel`_ has joined #ocaml
yunxing has quit [Remote host closed the connection]
cnu- has joined #ocaml
seangrove has joined #ocaml
sh0t has quit [Quit: Leaving]
<Reshi>
Hi, is there any good more for writing .mly files (for ocamlyacc). Tuareg highlights it but not correctly. And ocp-indent doesn't do any indentation.
FreeBird_ has joined #ocaml
govg has quit [Ping timeout: 240 seconds]
FreeBirdLjj has quit [Ping timeout: 276 seconds]
therac25 has quit [Quit: therac25]
BitPuffin|osx has quit [Ping timeout: 264 seconds]
yunxing has joined #ocaml
Emmanuel`_ has quit [Quit: Konversation terminated!]
Emmanuel`_ has joined #ocaml
FreeBird_ has quit [Remote host closed the connection]
FreeBirdLjj has joined #ocaml
<seangrove>
Hrm, `| `Error err -> raise (Failure (EC2.Errors.to_string err))` gives me error `Error: This expression has type EC2.AllocateAddress.error Aws.Error.t but an expression was expected of type EC2.Errors.t = Aws_ec2.Errors.t`
<seangrove>
I'm kind of confused re the diff between : `EC2.AllocateAddress.error Aws.Error.t` and just `Aws.Error.t`
johnelse has quit [Ping timeout: 240 seconds]
Emmanuel`_ has quit [Quit: Konversation terminated!]
Emmanuel`_ has joined #ocaml
Mandus has joined #ocaml
johnelse has joined #ocaml
yunxing has quit [Remote host closed the connection]
<seangrove>
seliopou: ^ any ideas?
yunxing has joined #ocaml
govg has joined #ocaml
struk|desk|away is now known as struk|desk2
Emmanuel`_ has quit [Quit: Konversation terminated!]
Emmanuel`_ has joined #ocaml
struk|desk2 is now known as struk|desk|away
Emmanuel`_ has quit [Quit: Konversation terminated!]
Emmanuel`_ has joined #ocaml
hxegon has quit [Max SendQ exceeded]
ygrek has joined #ocaml
ggole has joined #ocaml
keep_learning has joined #ocaml
Emmanuel`_ has quit [Quit: Konversation terminated!]
Emmanuel`_ has joined #ocaml
ygrek has quit [Ping timeout: 248 seconds]
hxegon has joined #ocaml
hxegon has quit [Client Quit]
kushal has quit [Quit: Leaving]
<seangrove>
Algebr: Feeling pretty comfortable with the ocaml-aws EC2 api now that the general shape makes sense (barring the above issue trying to get the error into a string), able to do lots of stuff now. Porting the script tomorrow should be straightforward.
manizzle has quit [Quit: Leaving]
ggole_ has joined #ocaml
manizzle has joined #ocaml
hxegon has joined #ocaml
GeorgeHahn has quit [Read error: Connection reset by peer]
ggole has quit [Ping timeout: 276 seconds]
Reshi has quit [Ping timeout: 268 seconds]
ggole__ has joined #ocaml
FreeBirdLjj has quit [Remote host closed the connection]
FreeBirdLjj has joined #ocaml
ggole_ has quit [Ping timeout: 244 seconds]
kushal has joined #ocaml
larhat has joined #ocaml
yunxing has quit [Read error: Connection reset by peer]
yunxing has joined #ocaml
govg has quit [Read error: Connection reset by peer]
govg has joined #ocaml
dsheets has joined #ocaml
dsheets has quit [Ping timeout: 250 seconds]
larhat has quit [Quit: Leaving.]
govg has quit [Ping timeout: 276 seconds]
struk|desk|away is now known as struk|desk2
MercurialAlchemi has joined #ocaml
badon has quit [Quit: Leaving]
therac25 has joined #ocaml
<flux>
please_help, well, even "simple" things like multiplying matrices is going to boost ML stuff significantly
<flux>
please_help, of course the trick is then arranging that the data is in a format suitable for the kernel, and that the format of the data persists that way all the time, instead of copying around.. and that the data can be fed from one kernel to the next without a round-trip to cpu memory :)
<flux>
please_help, sure these things can be as difficult as you make them but I have hopes it's achievable :)
hxegon has quit [Quit: BRB]
troydm has quit [Ping timeout: 244 seconds]
Emmanuel`_ has quit [Quit: Konversation terminated!]
Emmanuel`_ has joined #ocaml
dsheets has joined #ocaml
dsheets has quit [Ping timeout: 250 seconds]
struk|desk2 is now known as struk|desk|away
antkong has quit [Quit: antkong]
badon has joined #ocaml
ggole_ has joined #ocaml
ggole__ has quit [Ping timeout: 248 seconds]
Emmanuel`_ has quit [Quit: Konversation terminated!]
Emmanuel`_ has joined #ocaml
copy` has quit [Quit: Connection closed for inactivity]
ggole__ has joined #ocaml
ggole_ has quit [Ping timeout: 252 seconds]
<companion_cube>
please_help: well GPU is really necessary for DL, but not for other kinds of algorithms, aren't they?
<companion_cube>
anyway I suppose linking to tensorflow would indeed be the simplest way of using DL in OCaml
Haudegen has quit [Ping timeout: 244 seconds]
larhat has joined #ocaml
teknozulu has joined #ocaml
<teknozulu>
Hey. Say I have a list of first class modules, of a module type that contains type t. Is there a conceivable way to programmatically create a sum type of all the type t's, e.g "A of t1 | B of t2..."
<ggole__>
teknozulu: no, types aren't dynamic like that
<ggole__>
You might be able to build a dynamic structure that does what you want, though.
ggole__ is now known as ggole
<teknozulu>
I see. I was a bit surprised to find that you can't add sum types by doing something like... type t1 = A of int | B of string and then type t2 = C of float | t1, which would've provided a blimp of hope
yunxing has quit [Read error: Connection reset by peer]
<teknozulu>
but yeah I'll have to spend more time thinking about the proper approach
Emmanuel`_ has quit [Quit: Konversation terminated!]
Emmanuel`_ has joined #ocaml
<teknozulu>
I'm giving a stab at writing a certain kind of a distributed computing lib, and right now I'm at a point where I'm trying to implement the functionality for the following situation: there are two (or more) Rpc workers, and a subworker which depends on those two. The two workers send their output to the subworker over Rpc, however their outputs are of different types. The subworker hosts Rpc implementations for both of the workers, and has a
<teknozulu>
function 'a -> 'b -> 'c ('a and 'b denoting the types of the two workers outputs) that actually performs its work.
<teknozulu>
what I'm struggling with is closing the gap between the two worker's values arriving at the subworker, and actually calling the subworker's function with the two values
butts_butts has joined #ocaml
<teknozulu>
I want to take as much of the work away from the user of the library as possible, i.e. in the ideal situation they can write their function as 'a -> 'b -> 'c, without having to deal with any type gymnastics involved in managing the heterogenous types etc
<teknozulu>
Let me describe the situation in a more compact manner that still describes the problem I have:
therac25 has quit [Quit: therac25]
<teknozulu>
I have functions 'a -> unit and 'b -> unit, which get called in an asynchronous manner. I need to stick 'a and 'b into some sort of an intermediate container, which permits calling of a functiion 'a -> 'b -> 'c with the stored values
Haudegen has joined #ocaml
<teknozulu>
I made some progress but reached what I think is a dead end, with me passing the user's function a table with string keys and values with type information hidden by a universal
<ggole>
Hiding the type information isn't enough: you need to be able to recover type equality between the 'a in 'a -> unit and the 'a in 'a -> 'b -> 'c to be able to use the value passed to the former as an argument to the latter.
<ggole>
You could try to store witnesses, but it gets hairy.
therac25 has joined #ocaml
<teknozulu>
right, im not quite experienced enough to be able to formulate the exact answer but i have a hunch everything that needs the type has to be packaged together before hiding the type
<ggole>
Yeah, you usually package things into value/witness pairs such as type any = Any : 'a * 'a TypeEq.t -> any
Simn has joined #ocaml
<ggole>
Where TypeEq provides enough information for type safe coercions
<ggole>
I have to go and handle something irl right now, so good luck.
butts_butts has quit [Ping timeout: 244 seconds]
Emmanuel`_ has quit [Quit: Konversation terminated!]
Emmanuel`_ has joined #ocaml
<teknozulu>
thanks
ygrek has joined #ocaml
octachron has joined #ocaml
Sorella has quit [Quit: Connection closed for inactivity]
FreeBirdLjj has quit [Remote host closed the connection]
mort___ has joined #ocaml
FreeBirdLjj has joined #ocaml
therac25 has quit [Quit: therac25]
mort___ has quit [Client Quit]
Vintila has joined #ocaml
orbitz_ has joined #ocaml
mort___ has joined #ocaml
Emmanuel`_ has quit [Quit: Konversation terminated!]
Emmanuel`_ has joined #ocaml
orbitz has quit [Ping timeout: 240 seconds]
silver has joined #ocaml
FreeBirdLjj has quit [Remote host closed the connection]
FreeBirdLjj has joined #ocaml
warp has joined #ocaml
Kakadu has joined #ocaml
yomimono has joined #ocaml
ia0 has quit [Quit: leaving]
Emmanuel`_ has quit [Quit: Konversation terminated!]
Emmanuel`_ has joined #ocaml
ia0 has joined #ocaml
Reshi has joined #ocaml
rand__ has joined #ocaml
darkf has quit [Quit: Leaving]
orbitz_ has quit [Quit: Reconnecting]
nicholasf has quit [Ping timeout: 244 seconds]
nicholasf has joined #ocaml
pierpa has joined #ocaml
Emmanuel`_ has quit [Quit: Konversation terminated!]
Emmanuel`_ has joined #ocaml
amirmc has joined #ocaml
orbitz has joined #ocaml
nicholasf has quit [Ping timeout: 260 seconds]
kushal has quit [Ping timeout: 240 seconds]
FreeBirdLjj has quit [Remote host closed the connection]
FreeBirdLjj has joined #ocaml
sepp2k has joined #ocaml
mort___ has quit [Quit: Leaving.]
jwatzman|work has joined #ocaml
mort___ has joined #ocaml
dsheets has joined #ocaml
FreeBirdLjj has quit [Remote host closed the connection]
FreeBirdLjj has joined #ocaml
mort___ has quit [Quit: Leaving.]
amirmc has quit [Quit: Leaving.]
mort___ has joined #ocaml
pierpa` has joined #ocaml
pierpa has quit [Ping timeout: 260 seconds]
teknozulu has quit [Ping timeout: 244 seconds]
averell has joined #ocaml
mort___ has quit [Ping timeout: 250 seconds]
mort___ has joined #ocaml
Emmanuel`_ has quit [Quit: Konversation terminated!]
jgjl has joined #ocaml
lolisa has joined #ocaml
Emmanuel`_ has joined #ocaml
Emmanuel`_ has quit [Client Quit]
Emmanuel`_ has joined #ocaml
Emmanuel`_ has quit [Quit: Konversation terminated!]
Emmanuel`_ has joined #ocaml
troydm has joined #ocaml
Ardeshir has joined #ocaml
<Reshi>
can `ocamldep` be wrong? I am generating a mylexer.ml file from mylexer.mll, and mylexer.ml opens module Myparser, for which I have myparser.ml and myparser.mli, yet `ocamldep` doesn't list it as a dependency
Emmanuel`_ has quit [Quit: Konversation terminated!]
Emmanuel`_ has joined #ocaml
<Kakadu>
AFAR, yacc parsser should open lexer module to use type for lexems defined in a lexer
<Kakadu>
AFAIR*
<Kakadu>
I.e. there some default dependency between ocamlyacc and ocamllex files
profan has quit [Ping timeout: 240 seconds]
Ardeshir has quit [Excess Flood]
profan has joined #ocaml
mettekou has joined #ocaml
thomasga has joined #ocaml
jgjl has quit [Quit: My MacBook Pro has gone to sleep. ZZZzzz…]
sillyotter has joined #ocaml
sillyotter has quit [Client Quit]
mettekou has quit [Read error: Connection reset by peer]
mettekou_ has joined #ocaml
Emmanuel`_ has quit [Quit: Konversation terminated!]
kushal has joined #ocaml
mettekou_ has quit [Read error: Connection timed out]
yomimono has quit [Ping timeout: 260 seconds]
thomasga has quit [Remote host closed the connection]
_andre has joined #ocaml
Emmanuel`_ has joined #ocaml
reynir1 is now known as reynir
dsheets has quit [Remote host closed the connection]
nicholasf has joined #ocaml
Emmanuel`_ has quit [Quit: Konversation terminated!]
<Drup>
the prettiest operator in the OCaml libraries
<companion_cube>
obviously it's >>>?=, I wrote it recently
mettekou has joined #ocaml
Reshi has quit [Ping timeout: 248 seconds]
Reshi has joined #ocaml
struk|desk2 is now known as struk|desk|away
orbifx has joined #ocaml
<leyyin>
hi, I have a quite a newbish question, before I open Core.Std. `List.fold_left (+) 0 [1; 2; 3];;` works fine, but after I include it, it expects another signature, I thought that core was backwards compatible with non core ocaml :/
Emmanuel`_ has quit [Quit: Konversation terminated!]
Emmanuel`_ has joined #ocaml
mettekou has quit [Read error: Connection reset by peer]
<flux>
nope
<flux>
core rethinks some things for perhaps consistency
<flux>
leyyin, however, there is Batteries that on the other hand continues the conventions the ocaml standardlibrary takes
fluter has quit [Ping timeout: 240 seconds]
<orbifx>
Does Pervasives.String have a concatenation function?
<orbifx>
string1 + string2
<flux>
string1 ^ string2
<flux>
or String.concat for concatenating a list of strings with a separator
AlexRussia has joined #ocaml
dhil has joined #ocaml
<orbifx>
Thanks flux. Where is the documentation for this?
<leyyin>
ok, thanks for the answer, my question is now with core, why does `List.fold_left [1; 2; 3] 0 (+);;` return another function? I know I can do `List.fold_left [1; 2; 3] ~init:0 ~f:(+);;` but I do not want to write the named arguments :)
Emmanuel`_ has quit [Quit: Konversation terminated!]
<flux>
if you fully apply the arguments in the signature order, you don't need labels
Emmanuel`_ has joined #ocaml
<orbifx>
Ah thanks flux. I was looking in string.
<orbifx>
Also how can I append a character to a string? Must I convert first or is there a function?
<flux>
you must make a string of the character. String.make 1 'c' will do it for you.
<orbifx>
Ok. What's the most efficient container for this operation?
<flux>
I would go with Buffer
dsheets has quit [Ping timeout: 244 seconds]
<leyyin>
flux, I am doing that I think, but it returns another function :/
<flux>
leyyin, works on my computer(TM): # List.fold_left (+) 0 [1; 2; 3];; - : int = 6 :-)
<orbifx>
Thanks flux.
<leyyin>
flux, with Core.Std included?
fluter has joined #ocaml
* Kakadu
remembers a compiler switch about treating unalbelled arguments when labelled are expected as compilation error
<ggole>
-labels?
<ggole>
Er, -nolabels
<ggole>
But that isn't what that does.
dsheets has joined #ocaml
mettekou has joined #ocaml
freehck has quit [Remote host closed the connection]
Emmanuel`_ has quit [Quit: Konversation terminated!]
Emmanuel`_ has joined #ocaml
dsheets has quit [Remote host closed the connection]
dsheets has joined #ocaml
Reshi has quit [Quit: WeeChat 1.4]
<octachron>
leyyin, this is a special case: higher-order function whose result type is a type parameter (like fold_left) are never considered fully applied.
malc_ has joined #ocaml
<octachron>
so with core fold_left, `List.fold_left [1; 2; 3] 0 (+)` is interpreted as `fun ~f ~init -> List.fold_left ~f ~init [1; 2; 3] 0 (+)`
Vintila has quit [Ping timeout: 276 seconds]
tennix has quit [Ping timeout: 260 seconds]
<leyyin>
hmm, ok, so there is not way to call fold_left without specifying who is init and f and fully apply it, if I understood you correctly?
<orbifx>
If it possible to pattern match with an 'if' expression?
<aantron>
you mean get the same effect? match blah with | true -> ... | false -> ... ?
<octachron>
leyyin, yes, you need to go through the labels, since the compiler cannot guess that fold_left is fully applied
<orbifx>
/if it/is it/
<orbifx>
aantron: yeah, I need to match a specific constructor
<aantron>
ah. if there is no subpattern, then maybe
<aantron>
for example you can do "if my_list <> []"
<aantron>
or "if foo = None"
<aantron>
"if foo = `Some_constructor 0"
<orbifx>
But not "if = Some _"?
<aantron>
you grammatically can't write patterns inside the if expression, so no _
<octachron>
leyyin, as an simpler illustration with `let apply ~f x = f x and id x =x` both `apply ~f:id id` and `apply id id` are valid
Emmanuel`_ has quit [Quit: Konversation terminated!]
<aantron>
but "if foo = Some _" is the same as "if foo <> None"
Emmanuel`_ has joined #ocaml
<ggole>
No it isn't
<aantron>
why do you have this constraint that it must be an if expression?
<ggole>
None is an expression that returns a value which can be passed to =. Some _ is not.
<aantron>
ggole: i just said that Some _ is ungrammatical
<aantron>
so i am speaking loosely
<orbifx>
I have a custom type, with three constructors of something. At some point I need to print only for one of those
<ggole>
That would be an interesting language extension
<ggole>
Probably not appropriate given OCaml's treatment of equality though.
<ggole>
orbifx: either pattern match or write a function around a pattern match
<companion_cube>
I proposed `if let` but it wasn't accepted by most reviewers
<ggole>
Rust has that iirc
<orbifx>
Thanks ggole
<companion_cube>
yes, and it comes from swift
<companion_cube>
but OCaml maintainers were not convinced :)
<ggole>
eg given type t = Foo of int | Bar of zonk, you could have let when_foo f = function Foo x -> f x; () | _ -> ()
BitPuffin has joined #ocaml
<ggole>
I've heard "matches" suggested as an infix keyword that would behave like the above =
<leyyin>
octachron, thanks for the explanation
<ggole>
eg, x matches Foo _ returns a bool with the obvious meaning.
<ggole>
Certainly reads more cleanly than match x with Foo _ -> true | _ -> false
hxegon has joined #ocaml
<companion_cube>
but it's a new keyword, bleh
Emmanuel`_ has quit [Quit: Konversation terminated!]
Emmanuel`_ has joined #ocaml
<ggole>
Yeah, you really have to get in early with those.
<ggole>
Or go the pascal route and then you get to SHOUT every couple of WORDS.
keep_learning has quit [Quit: This computer has gone to sleep]
keep_learning has joined #ocaml
Emmanuel`_ has quit [Quit: Konversation terminated!]
Emmanuel`_ has joined #ocaml
Emmanuel`_ has quit [Client Quit]
Emmanuel`_ has joined #ocaml
pierpa has joined #ocaml
<orbifx>
Does selecting Open_binary mean that O_Noctty is set too?
mort___ has quit [Quit: Leaving.]
silver has quit [Quit: rakede]
FreeBird_ has joined #ocaml
FreeBirdLjj has quit [Ping timeout: 268 seconds]
tennix has joined #ocaml
<please_help>
It doesn't have to be just DL (well, it depends what you do consider DL, though - RNNs are often not considered DL, and they absolutely need GPUs). Any kind of software non-trivial software convolution is not going to work. Shallow networks didn't even offer good performance back in the 90's compared to deep nets anyway, even though it's really in 2006 that they started taking over everywhere, over SVMs. (SVMs do work on
<please_help>
CPUs though). RL (with prefab functions) and PC do not need GPUs but aren't ML. In general, a good checklist for "can it do machine learning" is: "can it do ranzato07?" "can it do RNN?" "can it do SVMs?", but just like you can handwrite a static html4 index.html and publish it as your website and call it web development, you can always play around with single FC layers and call it a ML. Don't expect anyone else to call it
<please_help>
that, though ;)
FreeBird_ has quit [Ping timeout: 268 seconds]
freehck has joined #ocaml
MercurialAlchemi has quit [Ping timeout: 248 seconds]
<companion_cube>
but as you said, SVM would be fine
<companion_cube>
of course it's not going to be a complete ML toolkit
<please_help>
Using SVM in 2016 is the ML equivalent of writing css and js-free, completely static webpages and calling it web development. It's not wrong, but it's not what people have in mind when they hear machine learning. Beside language (with heavily hand-crafted feature libraries) I don't think any field even gets good results wiht SVMs anymore. Well, I guess it's not that bad for video activity recognition which has only recently
<please_help>
been beat by two-streams and a few others.
mettekou has quit [Quit: My Mac has gone to sleep. ZZZzzz…]
yomimono has quit [Ping timeout: 240 seconds]
<companion_cube>
do people work on making DL less computationally expensive?
rand__ has quit [Quit: leaving]
jwatzman|work has quit [Quit: jwatzman|work]
malc_ has quit [Remote host closed the connection]
yomimono has joined #ocaml
<please_help>
Yes, it's actually a fairly "central" modern issue. Recently, nvidia added support for float16 with cudnn, this was a result of pretty much everyone agreeing we need it. There is also research into using integer or even binary weight matrices (especially combined with FPGAs, though).
kushal has joined #ocaml
<companion_cube>
because float16 is sufficient?
<companion_cube>
but I think (from the little I know) that learning should be faster, not just more optimized
<please_help>
Absolutely, for almost all cases. There are of course edge cases where the loss of precision is important, however.
Algebr``` has joined #ocaml
<please_help>
For learning to be faster, one would need a more efficient (stochastic) non-linear optimization algorithm that works well (not necessarily in theory, as long as it's good in practice) in highly non-convex landscapes.
<please_help>
Then you'll have to devise a way to get 3TB of data from system ram to vram faster, because that, too, is a bottleneck.
<companion_cube>
I suppose people have been trying the usual techniques, like simulated annealing
<please_help>
yeah, simulated annealing was popular many years ago. Nowadays we typically use ADAM, or RMSprop/adadelta. The main reason is that these methods do not need careful tuning of parameters and learning schedules to perform as well as a carefully crafted SGD, but they tend to also converge faster. We also end up using batch normalization because it helps learn faster.
Emmanuel`_ has quit [Quit: Konversation terminated!]
Emmanuel`_ has joined #ocaml
<mrvn>
I want something like: class oWidget = object(self) method show : unit [%External "caml_mrvn_QT5_OWidget_show"] end
<mrvn>
s/E/e/
<companion_cube>
please_help: do you work in ML? and where?
<please_help>
companion_cube: It will certainly be of interest to a class of RL researchers, and possibly to b.comp. neurosci folks./I am a masters's student in ML (DL, vision) currently in the process of writing my thesis.
<companion_cube>
that is pretty cool
<companion_cube>
you must be using lua or python currently, I presume
<please_help>
Python. Which is actually quite a bad match for ML. Late erroring is the worst. Run your job, 2 hours later it crashes because you forgot a comma somewhere, or you changed from a tuple to a simple value return type somewhere. At least there's lint.
d0nn1e has quit [Ping timeout: 260 seconds]
<Algebr```>
and you still pay for ec2 time wasted
d0nn1e has joined #ocaml
jeffmo has joined #ocaml
<please_help>
Thankfully we have our own clusters, but it's still a lot of time wasted that you could have used to tune parameters or try different model architectures. It really adds up.
octachron has quit [Quit: Leaving]
<aantron>
companion_cube: i see you added a monadic interface to gen. how was testing/using it?
copy` has joined #ocaml
govg has joined #ocaml
<companion_cube>
aantron: you mean the iterators? it's very natural to have a monadic interface
Emmanuel`_ has quit [Quit: Konversation terminated!]
Emmanuel`_ has joined #ocaml
jwatzman|work has joined #ocaml
<aantron>
but one has to choose a monad to program with them, or functorize over a monad.. ?
<aantron>
wish ocaml had a standard concurrency monad
<companion_cube>
lwt?
<Drup>
soon™
<companion_cube>
why would you have to "choose" a monad?
<companion_cube>
Drup: if you refer to effects, then it's going to not be a monad, but direct code \o/
<Drup>
it will solve the problem nevertheless
govg has quit [Ping timeout: 240 seconds]
<j0sh>
is it still possible to have an effects system without the full multicore mechanism around it?
d0nn1e has quit [Ping timeout: 244 seconds]
<companion_cube>
yeah, it will be so cool
<companion_cube>
j0sh: the effect system will not be directly tied to multicore
<companion_cube>
actually, I hope we get the effects before multicore
<j0sh>
yeah, it seems that multicore is being held up while effects is being refined though (at least, that's been my reading of it)
d0nn1e has joined #ocaml
Algebr``` has quit [Ping timeout: 268 seconds]
govg has joined #ocaml
yomimono has quit [Ping timeout: 264 seconds]
darkf has joined #ocaml
jwatzman|work has quit [Quit: jwatzman|work]
govg has quit [Ping timeout: 250 seconds]
manizzle has quit [Read error: Connection reset by peer]
manizzle has joined #ocaml
slash^ has joined #ocaml
<flux>
leyyin, oops
<leyyin>
:D
govg has joined #ocaml
<flux>
perhaps the problem with List.fold_left is that the last labeled argument is a function..
<flux>
leyyin, but you're correct, can't make it work :)
struk|desk|away is now known as struk|desk2
shinnya has joined #ocaml
larhat has quit [Quit: Leaving.]
Emmanuel`_ has quit [Quit: Konversation terminated!]
<mrvn>
re
<pierpa>
mi
<flux>
( so?)
<Kakadu>
wut?
<aantron>
fa!
Emmanuel`_ has joined #ocaml
Emmanuel`_ has quit [Client Quit]
Emmanuel`_ has joined #ocaml
<leyyin>
is there a way to display nicer error messages, instead of "Syntax Error" for `open randomstuffThatDoesNotExist;;`
<aantron>
for the uncapitalized r?
<aantron>
i guess it should be made nicer
<leyyin>
ah right :D
<leyyin>
it should start with an uppercase
<leyyin>
Unbound module RandomStuff
<leyyin>
but still, it should be nicer :P
<aantron>
yeah, especially towards people new to ocaml, and the idea that there are two classes of identifiers in the language
<aantron>
it's somewhat unusual
jstolarek has joined #ocaml
shinnya has quit [Ping timeout: 240 seconds]
<j0sh>
hmmm the browser vendors announced support for webassembly today, wonder if that'd be a better target for JSOO rather than plain JS
<Drup>
not yet
<Drup>
wasm is limited, no DOM, no GC ...
jstolarek has left #ocaml [#ocaml]
<pierpa>
hmmm... no GC? what should it be good for?
<Drup>
compiling C++.
<pierpa>
great! :)
<Drup>
wasm, just like asm.js, is kinda made for that ..
<pierpa>
pity
<Drup>
It should become better later, but for now, it's not very useful for us
<pierpa>
k
<mrvn>
I have have a ppx extension in my source. How do I get oasis to use it?
<Drup>
like other packages
<Drup>
oh, you mean, your own ppx inside the same set of packages defined in *one* oasis file ?
<mrvn>
yes
<Drup>
It's .. very painful
<mrvn>
ocamlfind: Package `ppx_external_method' not found
<Drup>
Are you sure you don't want to split the ppx out ?
<mrvn>
would be nice to get it working first than to have to build 2 pages for every attempt
<mrvn>
s/pages/&packages/
<Drup>
then you'll have to play with ppx
<Drup>
with ocamlbuild*
<Drup>
There is an example in lwt
<mrvn>
This works: ByteOpt: -ppx lib/ppx_external_method.native
<Drup>
that's going to be problematic for byte only archs
<mrvn>
Drup: right, why is it even working? I need BinaryOpt
<Drup>
use _tags instead
warp has quit [Ping timeout: 248 seconds]
jgjl has joined #ocaml
mort___ has joined #ocaml
<leyyin>
does anyone know how can I open xml-light? `Error: Unbound module Xml`, I installed xml-light with `opam install xml-light`
<aantron>
leyyin: you need to be linking with it
<aantron>
are you using ocamlbuild?
<leyyin>
the command I am using `ocamlopt read_xml.ml -I +xml-light -g -o read_xml`
<aantron>
switch to ocamlfind
dsheets has quit [Remote host closed the connection]
<companion_cube>
well those two OSes don't have the same binary format
<seangrove>
companion_cube: Hrm, I wonder if I used a 32bit instance
<companion_cube>
I don't think you can compile on mac and run on ubuntu (unless you explicitely do cross-compiling)
<seangrove>
Oh, really?
<companion_cube>
(and I know nothing about this)
<seangrove>
Damn.
<struk|desk2>
./main.native is not right either
<Kakadu>
Ubuntu has ELF. What does mac have?
<struk|desk2>
if you want a more portable binary
ggole has quit []
<companion_cube>
also, they might have different libc, etc.
<TheLemonMan>
kakadu, (fat-)mach-o images
<seangrove>
So I have to keep a linux box around to compile if I want to run my ocaml apps natively on some production linux boxes?
<companion_cube>
or compile on a machine that is similar to your production box?
yunxing has quit [Remote host closed the connection]
<companion_cube>
but yeah, I think so
<Kakadu>
or use byte code
<companion_cube>
maybe some cross compilation guru can help yu
<seangrove>
kakadu: Does that need ocaml on the production box to run?
yunxing has joined #ocaml
<Kakadu>
seangrove: It needs ocamlrun
<Kakadu>
not a compiler
<seangrove>
Yeah, none of that is optimal
<Kakadu>
but crosscompiling seems more decent approach
<seangrove>
Alright, I'll think about it a bit then, thanks!
<seangrove>
kakadu: I agree
<seangrove>
Heading out for a walk now, but will ask about that when I get back!
Emmanuel`_ has quit [Quit: Konversation terminated!]
Emmanuel`_ has joined #ocaml
yunxing has quit [Ping timeout: 260 seconds]
seangrove has quit [Ping timeout: 276 seconds]
<edwin>
could you run a virtual machine on your macbook with linux on it to compile your linux applications? or docker (but I guess that uses a VM on a macbook too)
<companion_cube>
yomimono: did you get the talk from mottl, too?
<yomimono>
!! whoever was recording was really stealthy
jgjl has quit [Max SendQ exceeded]
<yomimono>
companion_cube: ?
<companion_cube>
oh, sorry, misread
seangrove has joined #ocaml
dsheets has quit [Remote host closed the connection]
dsheets has joined #ocaml
Emmanuel`_ has quit [Quit: Konversation terminated!]
Emmanuel`_ has joined #ocaml
jgjl has joined #ocaml
Emmanuel`_ has quit [Quit: Konversation terminated!]
Emmanuel`_ has joined #ocaml
jgjl has quit [Max SendQ exceeded]
<yomimono>
companion_cube: I mean only that I was there and noticed nobody recording even while giving a talk :P
<companion_cube>
^^
<smondet>
yomimono: I think the room itself had cameras
<smondet>
that's why it's steady and the point-of-view changes
Haudegen has joined #ocaml
Algebr` has joined #ocaml
leyyin has quit [Quit: So Long, and Thanks for All the Fish]
yunxing_ has joined #ocaml
yomimono has quit [Ping timeout: 244 seconds]
yunxing has joined #ocaml
yunxing_ has quit [Ping timeout: 244 seconds]
yunxing has quit [Remote host closed the connection]
dsheets has quit [Remote host closed the connection]
Emmanuel`_ has quit [Quit: Konversation terminated!]
Emmanuel`_ has joined #ocaml
rotwatsb has joined #ocaml
yunxing has joined #ocaml
silver has quit [Quit: rakede]
sz0 has joined #ocaml
struk|desk2 is now known as struk|desk|away
nicholasf has joined #ocaml
butts_butts has quit [Ping timeout: 244 seconds]
<seangrove>
smondet: Which talk is this?
butts_butts has joined #ocaml
Emmanuel`_ has quit [Quit: Konversation terminated!]
Emmanuel`_ has joined #ocaml
butts_butts has quit [Ping timeout: 252 seconds]
Emmanuel`_ has quit [Quit: Konversation terminated!]
struk|desk|away is now known as struk|desk2
Emmanuel`_ has joined #ocaml
malc_ has joined #ocaml
<mehdib>
someone already used dead_code_analyzer?
ollehar1 has joined #ocaml
TheLemonMan has quit [Quit: "It's now safe to turn off your computer."]
MiiMo has joined #ocaml
MiiMo has quit [Client Quit]
Algebr`` has joined #ocaml
<ollehar1>
possibly silly question: how "close" is the PLT community to "solve" the effect problem? I mean, providing an industry language with typed effects?
<mrvn>
PLT community?
<mrvn>
does rust solve it?
<ollehar1>
programming-language theory.
<ollehar1>
rust does not have effects, as far as I know.
<mrvn>
see, problem solved
<ollehar1>
haha
Algebr` has quit [Ping timeout: 252 seconds]
<ollehar1>
_typed_ effects.
<mrvn>
can I inherit a class twice? class foo = object inherit bar as bar1 inherit bar as bar2 end?
<mrvn>
I want to get 2 seperate instances of bar
<mrvn>
class foo = object inherit bar 1 as bar1 inherit bar 2 as bar2 method bar = bar1#bar + bar2#bar end;;
<mrvn>
# foo#bar;;
<mrvn>
- : int = 3
<mrvn>
seems to work at first glance
antkong has joined #ocaml
antkong has quit [Client Quit]
<Algebr``>
you're really pushing the object system to the limits
<mrvn>
Algebr``: I might make bar1/bar2 values: val bar1 = new Bar 1 val bar2 = new Bar 2
<ollehar1>
I wonder if rust solved anything... except introducing ml-style programming to C++-programmers.
<ollehar1>
hm
<mrvn>
ollehar1: it has a widely different resource management
<ollehar1>
well, yes.
<ollehar1>
I'm just grumpy.
<mrvn>
too early to tell
<Algebr``>
ha
<mrvn>
I'm tempted to use Rust for kernel programming
<Algebr``>
I think objects even get their own .h file
<mrvn>
The following methods are undefined : squareWidth squareHeight painter
<mrvn>
drawSquare contentsRect
<mrvn>
*asigh* So much more bindings to do before it draws something.
<seangrove>
I don't suppose there's any work on concolic testing in OCaml? Seems like it's uniquely well-suite for it
<please_help>
ollehar1: rust has no GC and uses linear types to enforce coherence. As far as I know it's the first mainstream language to do so (but I'm not sure it's fair to call it mainstream yet...). Doesn't this count for something?
<ollehar1>
linear types? I thought they gave that up.
<please_help>
are they stuck on unique types? Or is it an even more precise subset?
<ollehar1>
regions is what I heard.
<ollehar1>
don't know.
Emmanuel`_ has quit [Quit: Konversation terminated!]
Emmanuel`_ has joined #ocaml
<please_help>
From a quick google it seems like it's unique types rather than linear types. Still.
<ollehar1>
typestate system ... was dropped in Rust 0.4.
<mrvn>
and it still looks the same as yesterday. :)
<mrvn>
maybe tomorrow I can draw a tetix piece.
ollehar1 has quit [Quit: ollehar1]
ollehar1 has joined #ocaml
<ollehar1>
uh, anyone tried koka?
<ollehar1>
don't know how to run compiled code... :P
<ollehar1>
ah nm, works now.
Kakadu has quit [Remote host closed the connection]
mettekou has quit [Quit: My Mac has gone to sleep. ZZZzzz…]
Vintila has joined #ocaml
Emmanuel`_ has quit [Quit: Konversation terminated!]
Emmanuel`_ has joined #ocaml
Emmanuel`_ has quit [Quit: Konversation terminated!]
Emmanuel`_ has joined #ocaml
seangrove has joined #ocaml
keep_learning has quit [Quit: This computer has gone to sleep]
<Algebr``>
companion_cube: see you made a space invaders game as well =p
dsheets has joined #ocaml
<companion_cube>
oh, you did, too?
<Algebr``>
when I was learning OCaml for realz, made lambda-invaders with lambda-term
<companion_cube>
ah yeah
<seangrove>
Drup: Yeah, I don't really care about those metrics.
<seangrove>
I really do like property-based/generative testing, and I love the idea of bringing in symbolic execution to guide it
<ollehar1>
sorry for OT, but does anyone know if it's possible to create new effects in koka? there seems to be a bunch of built-ins, like dev, exn, ndet.
<seangrove>
The easier you can make it the better
nicoo has quit [Remote host closed the connection]
<companion_cube>
ollehar1: I think there are slides on the site of koka, that explain stuff like that
<ollehar1>
companion_cube: ok, will check more closely.
<companion_cube>
seangrove: symbolic execution sounds really hard
<seangrove>
Very impressive stuff, even compared to e.g. simple/quickcheck
dsheets has quit [Ping timeout: 276 seconds]
<companion_cube>
yeah ok, concolic testing... it requires powerful tooling
<seangrove>
companion_cube: Oh, certainly. But I also like the idea of being able to combine it with effect-handlers at some point
<seangrove>
Anyway, just seems like it's kind of up OCaml's alley
<Drup>
Afaik, the only symbolic execution engine for ocaml is flambda, and it's very partial :p
<companion_cube>
or CFML
<companion_cube>
but, well
<Algebr``>
companion_cube: you are throwing an exception after "you lost"
<Algebr``>
companion_cube: David, author of notty, says you are the best ever.
<companion_cube>
ah, it continues playing? :D
<Algebr``>
also throws exception when I do a resize
<companion_cube>
hey, his library is awesome
<companion_cube>
yeah yeah, didn't want to deal with resize
<companion_cube>
I was just doing this tonight
<Algebr``>
just fyi really
<companion_cube>
^^
tani has joined #ocaml
yomimono has joined #ocaml
tane has quit [Ping timeout: 244 seconds]
shinnya has joined #ocaml
Emmanuel`_ has quit [Quit: Konversation terminated!]
Emmanuel`_ has joined #ocaml
<Algebr``>
Drup: Can I give tyxml HTML and have it try to parse it or something and tell me if its crappy HTML
<Drup>
runtime or compile time ?
<Algebr``>
either
<Drup>
runtime, no
<Drup>
compile time, yes, next version
<aantron>
Algebr``: markup.ml does that. your_questionable_html |> Markup.parse_html ~report:(fun _ _ -> failwith "this HTML is crappy!! n00b!")
<Algebr``>
Okay, what if i had an ocaml string with one big html document and validated it that way
<Algebr``>
k
<Algebr``>
aantron: nice!
<Drup>
aantron: doesn't tell if the html is correct, only if it's well formated ;)
<aantron>
if you actually use the arguments of ~report, you can see what the error is too. Error.to_string
<aantron>
thats not quite true, Drup
<aantron>
it doesnt do a full validation
<aantron>
but the html5 spec has a lot of error conditions that depend on semantics of html
<aantron>
and markup implements every single one of them, modulo mistakes i have made
<Drup>
such as ?
tani has quit [Quit: Verlassend]
seangrove has quit [Read error: Connection reset by peer]
<aantron>
e.g. <link> after </head>
<Drup>
Ah, I see
seangrove has joined #ocaml
<aantron>
again it isnt really complete, like i think the spec wont cause complains about <li> outside of a list.. but i think it requires to complain about <li> inside <em> (iirc)
<Algebr``>
aantron: what is some full example of crappy html?
<aantron>
and so on. we could write a "real" validator on top of markup.ml
<aantron>
are you asking if i have an example of a bad web page?
<Algebr``>
yea
<aantron>
hmmm. not sure if i have one handy
<aantron>
maybe if i go to some minecraft blog.. :p
<Algebr``>
ha. I'll make something nice for this quickly. I love your code