<lobo>
reynir: yes, you've already opened an issue yourself :D
Simn has quit [Ping timeout: 240 seconds]
jao has joined #ocaml
BitPuffin|osx 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
dhil has quit [Ping timeout: 240 seconds]
jao has quit [Ping timeout: 240 seconds]
trapz has joined #ocaml
trapz has quit [Quit: trapz]
Simn has joined #ocaml
<mrgrieves>
hi, newbie question here. So I'm trying to get my head around a couple of concepts in ocaml, 1) type sig & 2) tracing. Take insertionsort for example, I think I understand sort's sig but can someone explain what "insert --> <fun>" exactly means in the trace output? and what "<func>" means in the sig if it is something else othern than "sort is a function" ? https://pastebin.com/p79XSkUH
<n4323>
reynir: will this be in opam?
<reynir>
probably eventually :-)
<n4323>
looking forward!
kakadu_ has joined #ocaml
<theblatte>
hmm, how would one get out of warning 57 without code duplication? Eg for the example of the manual: | ((Const x, _) | (_, Const x)) when some_condition x -> branch (http://caml.inria.fr/pub/docs/manual-ocaml/comp.html#ss%3Awarn57)
<theblatte>
I guess I have to write an auxiliary function? :/
kakadu has quit [Ping timeout: 256 seconds]
<theblatte>
ah, lowering the `some_condition x` inside the branch should do it, thanks ;)
<theblatte>
so instead of an auxiliary function I still need an auxiliary value to hold the catch-all case to, oh well... `| ((Const x, _) | (_, Const x)) -> if some_condition x then branch else Lazy.force default`
<theblatte>
hmm, that's worse than the function solution because it's hard to know what to do in the `else` branch, it depends on the patterns that follow... has anyone written a ppx for that? ;)
jnavila has joined #ocaml
dhil has joined #ocaml
AlexDenisov has joined #ocaml
octachron has joined #ocaml
spew has joined #ocaml
jabroney has joined #ocaml
<mrgrieves>
while playing around and learning how can I stop merlin from giving me "Unbound value" warnings for functions that are present in a separate file within the same project/directory?
<octachron>
mrgrieves, you need to add a "S source_file_directory" and "B built_object_directory" fields to your .merlin file
<octachron>
mrgrieves, in the toplevel trace output "insert <-- 0; insert --> <fun>" means that feeding 0 to insert yields a function ("insert 0") which cannot be printed
mengu_ has joined #ocaml
govg has quit [Quit: leaving]
<mrgrieves>
octachron: thanks, my intuition was telling me something along those lines re trace but wanted some confirmation so I can sleep better at night ...
<mrgrieves>
gonna change my .merlin with your suggestions
<mrgrieves>
thanks
mengu has quit [Ping timeout: 260 seconds]
trapz has joined #ocaml
dhil has quit [Ping timeout: 246 seconds]
asdf1234 has joined #ocaml
jnavila has quit [Quit: It was time]
mengu_ has quit [Remote host closed the connection]
mengu has joined #ocaml
<lapinot>
hi, i was looking at hmap (heterogenous maps library) and also at http://alan.petitepomme.net/cwn/2015.03.24.html#1 and i had some question: in the linked code, the function witness : unit -> 'a witness creates a type witness (or "representation") but different calls to (witness () : int witness) yield incompatible type witnesses, ie a type witness is only compatible with itself
<mrgrieves>
so i keep getting these warnings https://pastebin.com/Xra75fcH . take, length, drop are defined in lib/ch4.ml if lib is declared as source in .merlin why I keep getting the warnings?
richi235 has quit [Ping timeout: 260 seconds]
<lapinot>
of course this is useful when implementing a mapping but i would have another usecase and would like an interface more like: wrap : 'a -> t and unwrap : t -> 'a option
<lapinot>
haskell has Data.Typeable.TypeRep but is something like that possible in ocaml?
<def`>
lapinot: what would determine thie second 'a from unwrap?
mengu has quit [Ping timeout: 240 seconds]
<def`>
mrgrieves: merlin needs other files to be built (ocamlc ...) to make use of them
<lapinot>
def`: a type annotation this is perfectly definable, i have a valid definition of wrap and unwrap which almost works, but because two different calls to witness with the same type aren't compatible, unwrap always returns None
<def`>
the only safe implementation, up to effects, of unwrap is fun _ -> None
<def`>
you have to pass a witness
<mrgrieves>
I forgot to mention that the warnings I'm talking about are vim warnings
<def`>
mrgrieves: I understand, but you need to have other ocaml files built to make merlin works
<mrgrieves>
just trying to find a suitable workflow
<def`>
is your project building?
<lapinot>
def`: apparently not, gonna paste what i have
<def`>
lapinot: this is what I said, your unwrap can only return None
<lapinot>
so is haskells TypeRep too magic to be implemented in ocaml?
<def`>
the magic is that haskell pass the witness for you
<def`>
this is just the "magic" of typeclasses, the problem doesn't have to do with TypeRep.
sh0t has joined #ocaml
<def`>
in haskell you would have: TypeRep a => T -> Maybe a
<def`>
in OCaml: 'a witness -> t -> 'a option
<def`>
In a parametric system, you have to pass the witness
<lapinot>
hmm and i assume "memoizing" the `witness` function (which would "solve" the problem of passing the witness but without the user doing anything) could not really work
<def`>
I am not sure what you mean but I don't think you can improve on this solution.
<companion_cube>
I don't think you can memoize
<companion_cube>
but you can export it
<lyxia>
I can't see how memoization would solve the problem of explicitly passing the parameter
al-damiri has joined #ocaml
<lapinot>
def`: i mean to memoize `witness` in such a way that `witness () : 'a tid` returns only one canonical tid for type 'a
<lapinot>
lyxia: if there is a canonical tid for each type then annotating the type is equivalent to passing a witness
<def`>
lapinot: the problem is that "each type" is not even well defined in OCaml
<mrvn>
lapinot: let memoized fn witnes = fn witnes?
<def`>
module X : sig type a end = struct type a = int end;;
<mrvn>
You would still have to pass the witness once
<octachron>
lapinot, this cannot works in OCaml: the module system can hide type equalities.
<def`>
should the tid for X.a be the same as the one for int?
<def`>
(that would break abstraction)
<lapinot>
def`: indeed, each abstract type would have it's own tid
<def`>
lapinot: so the id is the same inside X and become different outside X ?
<mrvn>
def`: a tid would have top have the full path with all specified equalities
<lapinot>
def`: yeah, now i get it
<mrvn>
s/top/to/
<def`>
mrvn: with gadt (or just functors) you can make equalities disappear then reappear
<def`>
so that would not behave very well
<mrvn>
def`: disappearing happens on every module interface if the type is hidden. As for reappearing, I don't think so. You can have witnesses that keep the type and transfere it back to some boxed thing. But that should be well defined.
<mrvn>
And funtors create a new module so that is a new type, which can be equal to an existing type or not.
<def`>
mrvn: the witness is dynamic
<def`>
but you would like the tid to be defined statically
<mrvn>
well, that would be imposible. any polymorphic function would have a dynamic tid.
<def`>
so that's where you start having discrepancies between dynamic and static semantics
<def`>
a.mli: type a b.mli: type b c.mli: val eq : (A.a, B.b) eq
<mrvn>
shouldn't that fail for abstract types?
<def`>
who knows, it depends how A, B and C are implemented.
<mrvn>
imho 2 abstract types should never be equal.
<def`>
the problem is not your opinion, the problem is that they can be equal :D
<def`>
module X : sig type a type b val x : (a, b) eq end = struct type a = int and b = int let x : (a,b) eq = Refl end;;
<mrvn>
def`: that is not an equality of abstract types.
<def`>
mrvn: it is
<mrvn>
the "let x" knows that both a and b equal int.
<mrvn>
and "val x" then says: a and b may be abstract but they have equality.
<def`>
of course, you can only introduce the equality when types are not abstract (unless it is syntactically the same type)
<def`>
the same in my example
<def`>
and you can only tell that at runtime after linking and loading C
<mrvn>
that's what I ment. In C above the equality should give an error since the types are abstract.
<lapinot>
for an equality witness you can look at type ('a, 'b) teq i defined in my snippet
<lapinot>
it is quite like what def` said
MercurialAlchemi has quit [Ping timeout: 260 seconds]
<mrvn>
The X example is actually quite nice. It shows that you can hide the implementation of a and b but still expose the promise that they are equal.
<mrvn>
The next version of the module you have type a = float type b = float and it would have the same interface.
<lapinot>
could we imagine something like higher-kinded type equality? In haskell that's straightforward but in ocaml they should maybe be wrapped in some module to encode higher-kinded polymorphism
<lapinot>
(just asking if anyone has some answer before i start trying)
<def`>
higher-kinded type equality? like showing that forall 'a, 'a t = 'a u
<def`>
I would use witnesses and the lightweight higher kinded types approach
ciniglio has quit [Remote host closed the connection]
alienbot has quit [Quit: No Ping reply in 180 seconds.]
tane has joined #ocaml
alienbot has joined #ocaml
gtrak has joined #ocaml
<mrgrieves>
def`: it is not building, but at the moment all I'm trying to do is to get familiar with the language while also understanding how to use some project tooling i.e. merlin . To give you an idea I'm trying to go over then contents of the book "ocaml from the very beginning" and I thought start writing ml files per chapter, with vim + merlin + tmux + vim-slime + utop I've got some sort of worklflow that
<mrgrieves>
the thing now is that as soon as I started having funcs in different files merlin complains everytime I save a file in vim
<mrgrieves>
def`: let me try
gtrak has quit [Client Quit]
gtrak has joined #ocaml
marsam has joined #ocaml
<mrgrieves>
interesting ... they build with some warnings I don't see in vim (i.e. I do get the not exhaustive ones in vim) https://pastebin.com/zciHtCW1
<mrgrieves>
I guess this is somehow type checking fully enforced
<def`>
corebuild is checking more warnings by default
<def`>
now, in ch5, you should do open Ch4 to get the content of ch4.ml in scope
<def`>
and merlin should stop complaining about these definitions.
<mrgrieves>
aha, scopes - yes that makes sense
<mrgrieves>
yep, that does the trick - in toplevel I was doing #use "ch4.ml"
<def`>
yes, the toplevel works more like C includes -- copying the content of the file inside another one
<def`>
this doesn't scale, bigger projects have multiple separate modules
shinnya has joined #ocaml
trapz has quit [Quit: trapz]
zpe has quit [Remote host closed the connection]
infinity0_ has joined #ocaml
infinity0_ has quit [Changing host]
infinity0 has quit [Killed (barjavel.freenode.net (Nickname regained by services))]
infinity0 has joined #ocaml
<mrgrieves>
def`: got it, thanks def`
infinity0 has quit [Remote host closed the connection]
<mrgrieves>
it's baby steps for me at the moment
gtrak has quit [Read error: Connection reset by peer]
<def`>
np, that's normal :)
<mrvn>
mrgrieves: I suggest restarting the top level frequently so you start with a blank slate again.
infinity0 has joined #ocaml
infinity0 has quit [Remote host closed the connection]
MercurialAlchemi 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]
freyr has quit [Remote host closed the connection]
infinity0 has joined #ocaml
infinity0 has quit [Remote host closed the connection]
<mrgrieves>
mrvn: yes I saw something along those lines somewhere, thanks
trapz has joined #ocaml
jabroney has quit [Quit: Leaving.]
MercurialAlchemi has quit [Ping timeout: 260 seconds]
infinity0 has joined #ocaml
MercurialAlchemi has joined #ocaml
ciniglio has joined #ocaml
<cranmax>
Hello, is someone developing OCaml in Red Hat 7? It works fine?
<Drup>
well, he work with OCaml *at* Red Hat, but I guess the two are related :p
spew has joined #ocaml
Guest95992 is now known as micro_
mrvn has quit [Remote host closed the connection]
trapz has quit [Quit: trapz]
<cranmax>
Ok, thanks
trapz has joined #ocaml
trapz has quit [Ping timeout: 240 seconds]
jabroney has joined #ocaml
mrvn has joined #ocaml
<johnelse>
cranmax: citrix xenserver is based on CentOS 7 and contains a lot of ocaml
<cranmax>
johnelse: then ocaml may work fine in rhel7, thanks
jao has joined #ocaml
spew has quit [Quit: foobar]
mrgrieves has quit [Quit: Lost terminal]
AlexDenisov has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
spew has joined #ocaml
trapz has joined #ocaml
trapz has quit [Ping timeout: 268 seconds]
ygrek has quit [Ping timeout: 260 seconds]
eh_eff has joined #ocaml
infinity0 has quit [Remote host closed the connection]
richi235 has joined #ocaml
copy` has joined #ocaml
<rwmjones>
cranmax: there is indeed a RHEL 7 OCaml compiler available; it is somewhat old (4.01 IIRC) because we are bound by backwards compatibility constraints
<rwmjones>
having said that, there is talk of upgrading to the latest version in RHEL 7.5
<def`>
asdf1234: you have multiple definition of point 2d
<def`>
you should start from a clean toplevel
<asdf1234>
def`: thanks!
<cranmax>
rwmjones: yes I have seen that is 4.01 the last in rhel7.3 so I may install this or it's possible to install newer versions via Opam?
<rwmjones>
sure you can use opam
<rwmjones>
it's your choice - do you want the stock compiler that you can install with yum, or do you want the latest compiler and you manage it yourself with opam, different solutions suit different people
govg has joined #ocaml
AlexDenisov has joined #ocaml
AlexDeni_ has joined #ocaml
AlexDenisov has quit [Ping timeout: 240 seconds]
marsam has quit [Remote host closed the connection]
sz0 has quit [Quit: Connection closed for inactivity]
Anarchos has joined #ocaml
gtrak has joined #ocaml
gtrak has quit [Read error: error:1408F10B:SSL routines:SSL3_GET_RECORD:wrong version number]
gtrak has joined #ocaml
gtrak has quit [Remote host closed the connection]
gtrak has joined #ocaml
kakadu_ has quit [Quit: Konversation terminated!]
Simn has quit [Ping timeout: 260 seconds]
trapz has joined #ocaml
<cranmax>
Thanks
freechips has quit [Ping timeout: 240 seconds]
marsam has joined #ocaml
BitPuffin|osx has quit [Ping timeout: 264 seconds]
Anarchos has quit [Quit: Vision[0.9.7-H-20140108]: i've been blurred!]
kakadu has joined #ocaml
freechips has joined #ocaml
AlexRussia has joined #ocaml
ygrek has joined #ocaml
freechips has quit [Client Quit]
eh_eff has quit [Ping timeout: 260 seconds]
AlexDenisov has joined #ocaml
AlexDeni_ has quit [Ping timeout: 260 seconds]
bernardo1pc has quit [Ping timeout: 260 seconds]
freechips has joined #ocaml
bernardofpc has joined #ocaml
vmonteco1 has joined #ocaml
AlexDenisov has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
<vmonteco1>
Hello! I'm trying to make a function to apply a xor on a string, but I don't get the error message I get : http://dpaste.com/2K0FPDK I get "This function has type int -> char. it is applied to too many arguments, maybe you forgot a ';' ". But How is this function getting more than one element here?
<rwmjones>
vmonteco1: it's a bit of a strange use of syntax there .. one wouldn't normally add so many type annotations
<rwmjones>
anyway the particular problem is that lxor is an infix operator, so:
<rwmjones>
let f n c = char_of_int (n lxor (int_of_char c))
<rwmjones>
this works for me:
<rwmjones>
# let xor s n =
<rwmjones>
String.map (f n) s;;
<rwmjones>
in
<rwmjones>
let f n c = char_of_int (n lxor (int_of_char c))
<rwmjones>
val xor : string -> int -> string = <fun>
<rwmjones>
(I accidentally indented the 'in' wrongly there)
Anarchos has joined #ocaml
<vmonteco1>
rwmjones: Are type annotations considered a bad practice? (I'm a beginner and it helps me to know what are the arguments). How can I tell the difference from arg1 OP arg2 and OP arg1 arg2 from the doc? The former have parenthesis around their name in documentation?
* vmonteco1
tries with suggested solution
<rwmjones>
so I believe that the way to tell it's inline is because it is defined with parentheses around it:
<rwmjones>
external ( lxor ) : int -> int -> int = "%xorint"
<rwmjones>
rather subtle!
<rwmjones>
if it was a prefix (normal) function it would have been defined:
<rwmjones>
external lxor : int -> int -> int = "%xorint"
<rwmjones>
s/inline/infix/
<vmonteco1>
Thats subtle indeed! I didn't know that. :)
<rwmjones>
as for type annotations, it is of course a matter of personal preference, but for large bodies of code that we write, we use them fairly rarely
<rwmjones>
there are a few type annotations there, but mainly for classes because the type inference in ocaml isn't too good at unifying objects (so it's for the benefit of the compiler, not for us)
<rwmjones>
and occasionally I add them if it's really not clear what the type is, or it's some obscure type
<rwmjones>
if you compile your code with -annot, then in emacs you can get the type of an expression using C-c C-t (and something similar in vi too)
<rwmjones>
having said that about rarely using type annotation, we *do* use lots of *.mli files to describe interfaces between modules, and those are full of types
<vmonteco1>
rwmjones: Assuming I have something like merlin installed I guess?
<vmonteco1>
rwmjones: Modules will be the next step for me :)
<rwmjones>
I wasn't familiar with that, but yes that sort of thing
<vmonteco1>
rwmjones: (Personnally, it saves me a lot of time by pointing out errors and explaining it.)
marsam has quit [Read error: Connection reset by peer]
<GomJabbar>
hello, trying to get ocaml setup on cygwin environment and im getting an annoying error: ocamlfind: C:OCamlib\ld.conf: No such file or directory, when i run: $ ocamlfind.exe printconf, i get The ld.conf file can be found here: C:OCamlib/ld.conf
<GomJabbar>
clearling the path is wrong
<GomJabbar>
there should be an extra slash in there
<GomJabbar>
but when i look at ld.conf theres nothing in it that specifies the directory of ld.conf
<GomJabbar>
so where exactly is it getting that path from?
<GomJabbar>
s/clearling/clearly
trapz has quit [Quit: trapz]
eh_eff has joined #ocaml
sepp2k has quit [Ping timeout: 240 seconds]
freechips has quit [Ping timeout: 264 seconds]
freechips has joined #ocaml
<GomJabbar>
ok solved that issue
<GomJabbar>
now im getting a weird one: ' unsupported mingw_arch: 'mingw64
<GomJabbar>
but the only ming installed is the one that CAME with the ocaml
Simn has joined #ocaml
<GomJabbar>
had to just manually remove that check from the configure
ygrek has quit [Ping timeout: 260 seconds]
argent_smith has quit [Quit: Leaving.]
mengu has joined #ocaml
al-damiri has quit [Quit: Connection closed for inactivity]
gtrak has quit [Quit: This computer has gone to sleep]
pzp has quit [Quit: Connection closed for inactivity]
spew has quit [Read error: Connection reset by peer]
Anarchos has quit [Quit: Vision[0.9.8]: i've been blurred!]
MercurialAlchemi has quit [Ping timeout: 268 seconds]
Simn has quit [Quit: Leaving]
kakadu has quit [Remote host closed the connection]
AlexRussia has quit [Ping timeout: 240 seconds]
AlexRussia has joined #ocaml
tane has quit [Quit: Leaving]
sh0t has quit [Remote host closed the connection]
taosx has joined #ocaml
<taosx>
Hey there, new to ocaml, trying to learn how to iterate over array but I believe some changes were made.
<taosx>
I wrote the following:
<taosx>
let names = [|"name0", "name1", "name2", "name3", "name4", "name5"|] in