<lapinot>
that's nice.. maybe my opinion about ocaml's build systems where too low ;)
<lapinot>
were*
snhmib has quit [Ping timeout: 268 seconds]
mengu has joined #ocaml
mengu has quit [Quit: Leaving...]
mengu has joined #ocaml
sz0 has joined #ocaml
<lapinot>
actually the problem is more deep.. i'm trying to use the %parameter of menhir but this forces me to separate files and this eventually leads to problems...
ryanartecona has joined #ocaml
wtetzner has joined #ocaml
spew has quit [Ping timeout: 260 seconds]
mengu has quit [Ping timeout: 260 seconds]
mengu has joined #ocaml
FreeBirdLjj has joined #ocaml
wtetzner has quit [Remote host closed the connection]
FreeBirdLjj has quit [Ping timeout: 264 seconds]
<lapinot>
maybe i found some way out, the only problem that remains is that because I need to group the 2 .mly file with a .mlypack, every option that got added to the token file (because of tags) get added to the other one
maattdd has joined #ocaml
chindy has quit [Remote host closed the connection]
mengu has quit [Remote host closed the connection]
marsam has quit [Remote host closed the connection]
pilne has quit [Quit: Quitting!]
silver has quit [Read error: Connection reset by peer]
infinity0 has quit [Ping timeout: 240 seconds]
infinity0 has joined #ocaml
infinity0 has quit [Remote host closed the connection]
trapz has quit [Ping timeout: 264 seconds]
trapz has joined #ocaml
infinity0 has joined #ocaml
infinity0 has quit [Remote host closed the connection]
infinity0 has joined #ocaml
infinity0 has quit [Remote host closed the connection]
trapz has quit [Quit: trapz]
infinity0 has joined #ocaml
infinity0 has quit [Remote host closed the connection]
infinity0 has joined #ocaml
infinity0 has quit [Remote host closed the connection]
infinity0 has joined #ocaml
infinity0 has quit [Remote host closed the connection]
trapz has joined #ocaml
infinity0 has joined #ocaml
maattdd has quit [Ping timeout: 260 seconds]
wagle has quit [Read error: Connection reset by peer]
wagle has joined #ocaml
sz0 has quit [Quit: Connection closed for inactivity]
wtetzner has joined #ocaml
ryanartecona has quit [Quit: ryanartecona]
trapz has quit [Quit: trapz]
manizzle has quit [Remote host closed the connection]
wtetzner has quit [Remote host closed the connection]
ohama has quit [Ping timeout: 260 seconds]
ohama has joined #ocaml
larhat has joined #ocaml
cbot has quit [Ping timeout: 240 seconds]
cbot has joined #ocaml
larhat has quit [Quit: Leaving.]
MercurialAlchemi has joined #ocaml
rpg has quit [Ping timeout: 256 seconds]
pzp has joined #ocaml
malc_ has joined #ocaml
spew has joined #ocaml
MercurialAlchemi has quit [Ping timeout: 240 seconds]
spew has quit [Quit: foobar]
Simn has joined #ocaml
MercurialAlchemi has joined #ocaml
\h has quit [Read error: Connection reset by peer]
d0nn1e has quit [Ping timeout: 256 seconds]
\h has joined #ocaml
d0nn1e has joined #ocaml
djellemah has joined #ocaml
_whitelogger has joined #ocaml
_whitelogger has joined #ocaml
emily1 has quit [Ping timeout: 264 seconds]
emily1 has joined #ocaml
jnavila has joined #ocaml
pzp has quit [Quit: Connection closed for inactivity]
orbifx has joined #ocaml
snhmib has joined #ocaml
orbifx has quit [Ping timeout: 268 seconds]
argent_smith has joined #ocaml
cbot has quit [Quit: Leaving]
AltGr has joined #ocaml
kakadu has joined #ocaml
rawra has joined #ocaml
zpe has joined #ocaml
FreeBirdLjj has quit [Remote host closed the connection]
FreeBirdLjj has joined #ocaml
wokalski has joined #ocaml
bezirg has joined #ocaml
mfp has joined #ocaml
mengu has joined #ocaml
<bezirg>
hello, I have a question of how the OO subtyping is implemented in OCaml (standard compiler). AFAIK, the mainstream OO languages (Java, etc.) use something called inclusive subtyping whereas there is no runtime cost when implicit subtyping. From what I understood, OCaml uses coercive subtyping, whereas on explicit upcasting (>:) there is a runtime price to pay to coerce the object to the specified class. Is that so?
<kakadu>
I don't think so. I don't even think that (:>) has some runtime cost
<bezirg>
kakadu: do you have perhaps any links where I can read more about the subtyping implementation?
<bezirg>
kakadu: of OCaml I mean
<kakadu>
It's tricky question
<kakadu>
basically you need to read not about classes but about object's representation
<n4323>
hi, a question about serialization: i would like to dump some or all values that exist at the end of one run of a native code program to disk, and then be able to run a bytecode version of the program in the toplevel and load those values and interact with them. with as little work as possible. what can i do?
<n4323>
basically like saving an entire 'matlab workspace' or doing DumpSave in mathematica..
mrgrieves has joined #ocaml
<def`>
You can do that with plain values.
<def`>
If there is no closure or foreign values (C heap), it's trivial.
<def`>
Look at Marshal module and Pervasives.input_value / output_value
<mrgrieves>
any vim+merlin users around? I've got omnicompletion working and turned merlin_completion_with_doc while I'm getting familiar with the language but the default behaviour seems to be to split the window horizontally
<companion_cube>
n4323: you can use Marshal
<orbifx-m>
thanks octachron
<def`>
mrgrieves: the default behavior is to use the preview window
<mrgrieves>
to display the docstrings . Any ideas how to autoclose the docstring windows once a selection is made?
<def`>
(actually that's vim behavior)
<def`>
mrgrieves: yes it can be scripted, wait a minute
<n4323>
def`: plain values would be enough i think. mainly just data. basically i would collect values i want to store and marshal them to individual files, yes?
<def`>
mrgrieves: au! CompleteDone * :pclose
<def`>
n4323: one or more, it's up to you. Marshal turns a values to bytes and back from bytes.
<def`>
n4323: however there is no type safety at all
<def`>
You have to be sure the type you unmarshal to is compatible representation-wise with what you are unmarshalling
<n4323>
def`: thanks! so i have to do sth like let (a:type_i_know) = Marshal.from_channel ...
<def`>
yes
<def`>
If the type is wrong, your program might run for sometime, erratically... Behavior is completely undefined :)
ciniglio has quit [Ping timeout: 246 seconds]
<theblatte>
it mostly segfaults on wrong types in my experience ^^ (but don't rely on that)
<n4323>
hm. not super elegant but i guess making something type-safe would require much more effort (also from me) is there type-safe serialization in some form as well?
<Drup>
with derivers, yes
wokalski has joined #ocaml
sepp2k has joined #ocaml
<n4323>
[@@ deriving sexp] ? would that work? or is something else easier?
<Drup>
you have several choice of format (sexp, json, bin_prot, ...)
<theblatte>
or with atdgen, which supports json and has a custom binary format too
sh0t has joined #ocaml
ciniglio has joined #ocaml
zpe has quit [Remote host closed the connection]
<companion_cube>
Drup: do you know if tags are supposed to be erased by @. ?
<Drup>
hum, unclear
jabroney has joined #ocaml
<Drup>
it wouldn't be extremely surprising if the current implementation did, but I'm not convinced if it supposed to do that.
<orbifx-m>
is it OK to call a C function taking 'value's from another taking 'value's so long I guard them with CAMLParam?
sh0t has quit [Remote host closed the connection]
Exagone313 has joined #ocaml
<def`>
yes.
<def`>
I mean... you have to guard all C variable of type value if they live in a scope where the GC can be invoked
<def`>
(e.g the inner function should also have CAMLparam)
<def`>
you can skip that by passing a value* or if you are sure that no GC can run..
shinnya has joined #ocaml
MercurialAlchemi has quit [Ping timeout: 258 seconds]
rpg has joined #ocaml
rpg has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
marsam has joined #ocaml
wokalski has quit [Ping timeout: 260 seconds]
after____ has joined #ocaml
after___ has quit [Ping timeout: 240 seconds]
marsam has quit [Remote host closed the connection]
marsam has joined #ocaml
marsam has quit [Read error: Connection reset by peer]
marsam has joined #ocaml
rpg has joined #ocaml
ygrek has joined #ocaml
freusque has joined #ocaml
freechips has quit [Quit: WeeChat 1.7]
after___ has joined #ocaml
after____ has quit [Ping timeout: 240 seconds]
rpg has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
wokalski has joined #ocaml
rpg has joined #ocaml
larhat has quit [Quit: Leaving.]
<wokalski>
hey. How do you cross compile opam packages? Besides switching to appropriate compiler is there any 'workflow'? I am asking because I skimmed through a few *.opam files and I feel like they make assumptions that we are building for the host?
rly has joined #ocaml
<rly>
How fringe is LEM (the software tool)? I.e., does anyone here use it?
copy` has joined #ocaml
<rly>
Sorry, "Lem".
freusque has quit [Quit: WeeChat 1.7]
BitPuffin|osx has quit [Ping timeout: 268 seconds]
trapz has quit [Quit: trapz]
ciniglio has quit [Ping timeout: 246 seconds]
cbot has joined #ocaml
shinnya has quit [Ping timeout: 260 seconds]
ziyourenxiang has quit [Quit: Leaving]
MercurialAlchemi has joined #ocaml
cdidd has quit [Ping timeout: 258 seconds]
sepp2k has quit [Ping timeout: 240 seconds]
al-damiri has quit [Quit: Connection closed for inactivity]
cdidd has joined #ocaml
trapz has joined #ocaml
mrgrieves has quit [Quit: Lost terminal]
wokalski has quit [Ping timeout: 260 seconds]
larhat has joined #ocaml
jnavila has quit [Quit: It was time]
rawra has quit [Quit: Connection closed for inactivity]
Anarchos has joined #ocaml
orbifx-m has quit [Ping timeout: 246 seconds]
hydrocat has joined #ocaml
ryanartecona has joined #ocaml
demonimin has quit [Remote host closed the connection]
<hydrocat>
Hello, I`m trying to write a really basic REPL but I'm failing to make a functional "while true" loop. Is this a good place to ask for help ?
philtor has quit [Ping timeout: 268 seconds]
<companion_cube>
while true do let line = input_line() in eval_line line; done
<companion_cube>
sth like this?
<hydrocat>
yeah, but I thought that the functional way would be to write a recursive function
demonimin has joined #ocaml
<octachron>
hydrocat, you can also have let rec loop state = … in loop new_state
<companion_cube>
let rec loop() = … in loop()
<rly>
What does the word "functional" even mean when I/O is involved?
<rly>
Sure, you can model I/O using functions.
<hydrocat>
good point rly
<rly>
Programming in C is also just programming in the C monad; it's just a fairly complex mathematical object.
<flux>
so how do you store a side effect to a variable in C?-)
<rly>
flux: function pointers.
<companion_cube>
using the programmable ';' monad!!
<reynir>
There were some students who asked Bjarne Stroustrup (C++ guy) when you'd be able to override the semicolon operator
<flux>
reynir, whitespace98.pdf
<rly>
hydrocat: you can also argue that even Haskell is not "functional", because it hides memory effects.
FreeBirdLjj has quit [Remote host closed the connection]
<rly>
hydrocat: or that we are not programming in the quantum monad, which we should all be doing for high-performance.
<flux>
I don't think you can argue that ;)
<rly>
Or in the "GrandTheoryOfEverythingMonad" *pending release.
<companion_cube>
in the hype monad*
<hydrocat>
rly: It just seemed to be the right, simplest way but it's starting to give me some headaches
<flux>
the typed effects for ocaml is pretty interesting, let's see if that could become an alternative to monads ;)
<flux>
it seems like they would compose better. or are they even a replacement for many monad applications?
freechips has joined #ocaml
philtor has joined #ocaml
<companion_cube>
it would compose better, probably, yeah
<companion_cube>
no transformer stack
cbot has quit [Ping timeout: 260 seconds]
<rly>
Is it undecidable to figure out whether a piece of code is compatible with a particular monad transformer stack?
<rly>
If not, then why do we even bother specifying types?
<hydrocat>
companion_cube: your looping code doesn't loop { let rec loop() = … in loop() }
<hydrocat>
companion_cube
<hydrocat>
companion_cube: I tried it in utop but it seems to only run once
<companion_cube>
let rec loop() = …; loop() in loop()
<rly>
hydrocat: he declares a recursive function named loop taking a tuple of one element as an argument, then has some arbitrary body and then calls the loop again. The last part is to actually start the loop.
<rly>
hydrocat: but you should just read a book.
<hydrocat>
rly: I was reading Real World Ocaml
<rly>
hydrocat: read a better book, if you had to ask that question.
<hydrocat>
rly: may I have some recommendations ?
marsam has quit [Remote host closed the connection]
<rly>
hydrocat: it might be that many people from this community do not like the author, however.
<companion_cube>
the author is a notorious troll
<rly>
companion_cube: what do you think about the book?
<hydrocat>
rly: Thank you
<companion_cube>
(when he adopts a technology, every other thing under the sun becomes extremely bad)
<companion_cube>
no idea, it might be good
<rly>
companion_cube: that could also be true, no?
<rly>
companion_cube: well, "extrememly bad" is often an overstatement, but still.
<rly>
extremely*
<rly>
"You've done a great job with that book. Thanks!" - Dr Xavier Leroy, lead developer of OCaml in INRIA, France.
<rly>
I don't know whether that is a lie or not, but you can't really get a better endorsement in the OCaml community.
<companion_cube>
:D
BitPuffin|osx has joined #ocaml
<rly>
I think it's character assassination; something which has happened before with other talented people.
<companion_cube>
ow do you mean?
<companion_cube>
+h
<rly>
companion_cube: As far as I recall, John Harrop did often present arguments and even running code to demonstrate his arguments.
BitPuffin|osx has quit [Remote host closed the connection]
<rly>
companion_cube: and especially if you write a book like this, I wouldn't care less if he would troll all day long.
<companion_cube>
yes, yes
<companion_cube>
but he focuses on the specific use cases he cares about and generalizes from them
<companion_cube>
(e.g. the whole multicore story, imho, doesn't actually matter much for most OCaml programs)
<rly>
companion_cube: so, why don't people just point that out and then the audience (with popcorn) can make up their own mind.
<rly>
companion_cube: if that was true, then why does every DBMS built during the 1980s-2000s use multiple cores in a single process?
<companion_cube>
sure
<companion_cube>
because DBMS are a very specific kind of program? :D
<octachron>
rly, at least, "Ocaml for scientists" comes with some caveats: it is quite geared towards numerical computations, the vizualisation/opengl part is outdated, and a lot may have changed concerning the optimization part
<companion_cube>
(also, why do we write Ocaml when virtually all kernels on earth are in C(++)?_
<rly>
companion_cube: it just reduces OCaml to be a non-general purpose programming language.
<companion_cube>
general purpose doesn't mean all purpose
<rly>
companion_cube: just like Python is.
<companion_cube>
because no language is all purpose
<hydrocat>
rly: Luckly, the first chapter is open and it describes the syntax a little better :)
<companion_cube>
but sure, OCaml doesn't run well on microcontrollers with 256B of ram, so it's not all purpose
<rly>
octachron: how would modern visualisation look like?
<companion_cube>
I suppose it would rely on ggplot-like stuff in a notebook? :p
<companion_cube>
or a modern OCaml library like archimedes
<rly>
Archimedes is 2D.
<octachron>
rly, lablgl/opengl 1 itself is (very) outdated
<companion_cube>
ah, this kind of visualization…
<rly>
octachron: I think the concepts it presents are fine.
<rly>
octachron: it's just that shaders, etc. are not in there.
rly has quit [Quit: WeeChat 1.5]
TheLemonMan has joined #ocaml
marsam has joined #ocaml
marsam has quit [Remote host closed the connection]
avsej has quit [Quit: Quit]
avsej has joined #ocaml
avsej has quit [Changing host]
avsej has joined #ocaml
avsej has left #ocaml [#ocaml]
marsam has joined #ocaml
j14159 has joined #ocaml
wtetzner has joined #ocaml
ryanartecona has quit [Quit: ryanartecona]
jabroney has quit [Quit: Leaving.]
IRCFrEAK has joined #ocaml
IRCFrEAK has quit [K-Lined]
sepp2k has joined #ocaml
average has joined #ocaml
malc_ has quit [Quit: ERC (IRC client for Emacs 25.0.50.2)]
average has quit [Remote host closed the connection]
spew has quit [Quit: foobar]
trapz has joined #ocaml
lamer14897856317 has joined #ocaml
lamer14897856317 has quit [K-Lined]
IRCFrEAK has joined #ocaml
IRCFrEAK has quit [K-Lined]
marsam has quit [Remote host closed the connection]
<tobiasBora>
Hello,
marsam has joined #ocaml
Simn has joined #ocaml
<tobiasBora>
Maybe it's related with the last discution, but I'd like to do a "game"-like interface using Ocaml. The problem is that I don't know how to choose the graphical interface. I use to like to program in Qt when I was using C++, but kakadu seems to say that it's "binding" is not very stable, for openGl I'm not sure how outdated the binding tgls/glMLite are (since lablgl is (very) outdated)
<kakadu>
define game-like
Simn has quit [Client Quit]
<tobiasBora>
kakadu: basiquely a game like Tetris, but for educational purpose, where I'd like to be able to draw functions, and I'd like also to be able to draw 3D graphs.
<tobiasBora>
so basiquely I don't need amazing graphical card support with GPU processing... but I'd like to have a nice render, with at least anti-aliasing stuff...