<basro>
Hello, is there any way to reference things computed in the pattern matching guard inside of the body?
<basro>
| MyCase x when let a = x + 1 in x < 3 -> (* use a here *)
<basro>
^something like that
malina has quit [Remote host closed the connection]
malina has joined #ocaml
silver has quit [Read error: Connection reset by peer]
_whitelogger has joined #ocaml
wolfcore has quit [Ping timeout: 240 seconds]
mfp has quit [Ping timeout: 255 seconds]
rgrinberg has quit [Ping timeout: 240 seconds]
vicfred has quit [Quit: Leaving]
_whitelogger has joined #ocaml
snhmib has quit [Ping timeout: 260 seconds]
yaewa has joined #ocaml
moei has quit [Ping timeout: 240 seconds]
FreeBirdLjj has joined #ocaml
IRCFrEAK has joined #ocaml
IRCFrEAK has left #ocaml [#ocaml]
FreeBirdLjj has quit [Remote host closed the connection]
FreeBirdLjj has joined #ocaml
FreeBirdLjj has quit [Ping timeout: 240 seconds]
nomicflux has joined #ocaml
FreeBirdLjj has joined #ocaml
nomicflux has quit [Quit: nomicflux]
larhat has joined #ocaml
jao has quit [Ping timeout: 260 seconds]
MercurialAlchemi has joined #ocaml
yaewa has quit [Quit: Leaving...]
moei has joined #ocaml
FreeBirdLjj has quit [Remote host closed the connection]
FreeBirdLjj has joined #ocaml
paileyb has joined #ocaml
<paileyb>
Hi all! I have a noobish compilation question (4.04.0). I have an x.cmi and x.ml file in the same directory. If I ocamlc -c x.ml it replaces the x.cmi file. But according to http://caml.inria.fr/pub/docs/manual-ocaml/comp.html: "If the interface file x.mli exists, the implementation x.ml is checked against the corresponding compiled interface x.cmi, which is assumed to exist." I'm trying to compile x.ml against the already compiled si
<paileyb>
Is there any way to compile against the cmi without having the mli present?
<paileyb>
If just `touch x.mli` it works, but this really doesn't make sense. Is there a flag I'm missing that allows you to compile without the mli?
<orbifx>
twold: your answer implies that I can't do it with the standard language?
<twold>
there are less heavyweight approaches but at the end of the day you need to be able to reflect the type representation into a value. here's another way of doing that http://okmij.org/ftp/ML/first-class-modules/#generics
<twold>
yes, my understanding is that you can't do this kind of things in ML languages
<flux>
orbifx, correct, there is no way to convert variants to a value containing all the variants in an iterable form
<flux>
orbifx, and it's solved by using a code generator that constructs such iterators or values for you
<flux>
personally I wouldn't bother unless I have a big list of such variants :)
<twold>
unless there is a special support in the compiler (Haskell has this in the form of Generics library which seems to be close to ppx_deriving https://github.com/whitequark/ppx_deriving).
zpe has joined #ocaml
<twold>
yep, I also wouldn't bother for small types :) but if you ever extend those types this code will break down, so it's not perfect...
<flux>
not necessarily, if you have used pattern matching and get exhaustiveness warnings
zpe has quit [Remote host closed the connection]
<flux>
but I agree it's easy to make it not happen, ie. by constructing assocation lists
<flux>
in fact there should be a syntax extension for triggering that kind of exhaustiveness checks ;-)
zpe has joined #ocaml
<orbifx>
if I wanted to allow extentions, I use polymorphic variants? Correct?
zpe has quit [Ping timeout: 268 seconds]
sepp2k has joined #ocaml
<orbifx>
and are polymorphic variants scoped? say if they are part of a module?
FreeBirdLjj has quit [Read error: Connection timed out]
FreeBirdLjj has joined #ocaml
<orbifx>
flux: ?
<Drup>
poly variants are not scoped
<Drup>
flux: ppx_deriving enum does what you want, by the way
<flux>
drup, I imagined there'd be something like that around, but haven't felt the need 'too hard' :)
<flux>
it would be nice if it were possible to write simple deriving ppx-extensions inline in OCaml code..
<flux>
of course now you'll tell me there's some ppx for doing that?-)
<Drup>
not really, no
<Drup>
and macros won't even help. You really need compiler support or ppx for this kind of things, since you need to manipulate the AST of the type definition
<jerith>
Leonidas: More things for you to review. :-)
dch_ has quit [Quit: ZZ]
skunkwerks has quit [Remote host closed the connection]
rcsole has joined #ocaml
<rcsole>
hi everyone! i'm getting started with ocaml and just wanted to say hello :) looking forward to meeting all of you!
<jerith>
Hello rcsole. :-)
<Leonidas>
jerith: \o/
<Leonidas>
I'm currently not at home but I'll try to find time this week :)
<Leonidas>
rcsole: welcome!
<rcsole>
thank you Leonidas and jerith!
rcsole has quit [Quit: Page closed]
<apache3>
what is the most pleasant way to develop graphical user interfaces in OCaml? LablGtk?
<apache3>
or use a java ide for the UI and run it in the jvm with ocaml-java?
<flux>
lablgtk.
<flux>
if you feel that adventurous you could try kakadu's lablqt
<flux>
QtQuick is pretty nice way to build GUIs!
rcsole has joined #ocaml
<apache3>
thanks!
<Leonidas>
twitter today: irc is dead, noone uses it, use slack
<Leonidas>
fast forward 2 years, slack closes down.
<apache3>
slack is closed?
<jerith>
I hope not. Then Leonidas will *never* review my pull requests.
<Leonidas>
apache3: no, I'm saying that once slack closes down, its dead, unlike IRC
<Leonidas>
jerith: :D
<apache3>
:)
<Leonidas>
jerith can just write his own slack which my library will continue to support ;)
FreeBirdLjj has quit [Remote host closed the connection]
<jerith>
Nah, I'm tired of writing messaging backends.
rcsole has quit [Remote host closed the connection]
rcsole has joined #ocaml
nomicflux has joined #ocaml
nomicflux has quit [Quit: nomicflux]
bobbypriambodo has joined #ocaml
bobbypriambodo has left #ocaml ["ERC (IRC client for Emacs 25.1.1)"]
bobbypriambodo has joined #ocaml
AlexDenisov has quit [Ping timeout: 260 seconds]
nomicflux has joined #ocaml
chetshah has joined #ocaml
nomicflux has quit [Client Quit]
<chetshah>
Hello all, Are there well known libraries for dealing with XML, also if possible converting some .xsd schemas (simple/complex types) to corresponding type defintions?
bobbypri` has joined #ocaml
bobbypriambodo has quit [Ping timeout: 260 seconds]
bobbypri` is now known as bobbypriambodo
<Drup>
Nothing is done for .xsd schemas. As for xml, the usual library is xmlm
<gjaldon__>
@jamesst20 there’s no `if then in` in OCaml
<jamesst20>
@jerith Thank you reading this now. gjaldon__ is there an alternative then? I am trying to add a child (with a letter) to a tree if that letter is not there in any child
Twister_ has quit [Quit: Page closed]
<jamesst20>
@gjaldon__ It looks like that : http://i.imgur.com/qUkn029.png Each branch has a letter, when we have a word, we have true, otherwise false
<jerith>
Something like "let x = if ... then ... else ... in ..." is legal, because "if" is an expression.
sepp2k has joined #ocaml
<jerith>
But your "then" and "else" expressions both need to have the same type.
<jamesst20>
jerith: But there is no way to do like, actions... if cond then actions 2 endif ... actions
<octachron>
jamesst20, a major misconception in your code is that variables are immutable (by default) in OCaml
<octachron>
"x = y; ()" does not affect the value y to x, it computes the result of the equality "x = y ?" then discards it
<jamesst20>
octachron: You mean line 15?
<octachron>
jamesst20, yes: l14 to 16 does … nothing
chetshah has quit [Quit: Page closed]
<gjaldon__>
@jamesst20 first you’ll need to define a custom data structure in OCaml that represents that tree
<jamesst20>
octachron: Yeah well line 16 was just because it wouldn't run without
<jerith>
Not entirely nothing. They will generate compiler warnings. :-P
<gjaldon__>
@jamesst20 then write a function that traverses that tree using recursion
<octachron>
jamesst20, well the code would not run because it was doing the wrong thing and ill-typed, adding line 16 juste made it well-typed
<jamesst20>
I am so lost... :/ I'm doing well with C++/Java/C#/Javascript, but OCaml is so different. I am not getting the logic behind the synthax
<jerith>
jamesst20: The problem here is that you're thinking in terms of imperative operations on mutable data.
<octachron>
jamesst20, the building block of functional programming are sligthly different than imperative language, it is normal to struggle at first
<jamesst20>
How am I suppose to think when doing functional programmaing?
<gjaldon__>
jamesst20: you’ll need to understand immutability and working with immutable data structures
<jerith>
Instead of writing a function that modifies a data structure, write one that returns a new data structure based on the immutable inputs.
<haesbaert>
also why don't you start with simpler stuff
<gjaldon__>
for example when adding an element to a list in FP, you always get a new list with that added element
<gjaldon__>
unlike when working with an array (a mutable data structure) you make ‘updates in place’ and don’t get a new array. you make changes to the actual array that was passed
<gjaldon__>
hope that makes sense
<jamesst20>
jerith: Working with big data structures must be so slow then ?
<jerith>
jamesst20: Not necessarily.
<jamesst20>
haesbaert: I would, however the work that has to be done is up to my teacher, not me :/
<haesbaert>
ah
<jerith>
You typically share parts of your immutable data, which is safe because it's immutable.
<haesbaert>
you don't copy a full record if you "create the same record with one different member"
<haesbaert>
if that's what you're thinking
<jamesst20>
Yeah it's what I was thinking
<jerith>
For gjaldon__'s list example, you're not returning a copy of the original list. You're returning "this new element followed by everything in this existing list".
<haesbaert>
basically all the old "common" members between old and new will still be the same (since it is imutable), both new and old will share the same members
<jamesst20>
jerith: So if I got it right. let myVar = true in while (myVar) do myVar=false done;; will result in an infinite loop because it's immutable?
<haesbaert>
jamesst20: I think it helps to think of "I can't modify variables", but I can attach new values to symbols
larhat has joined #ocaml
<haesbaert>
your while (myvar) will never change
<octachron>
jamesst20, yes. You should read "let x = f y in … " as let's name "x" the result of "f y" in the following "…"
<haesbaert>
because if in the body you do let myvar in, you're just giving a new value to the symbol myvar in a different scope
<jerith>
jamesst20: Yes. "while" loops rely on mutable state.
<gjaldon__>
jamesst20 using `while` and `for` loops in OCaml is for when you want program in an imperative style
<gjaldon__>
so you’ll need mutable state as jerith pointed out
<jamesst20>
gjaldon__: So while and for should be avoided?
<jerith>
jamesst20: Initially, it's probably a good idea to avoid them.
<jamesst20>
jerith: But how can you have mutable state?
<octachron>
jamesst20, another thing "=" in Ocaml corresponds to "==" in C-like language
<jamesst20>
octachron: Yeah I figured out, but I though it only meant == when we were speaking in a condition like an if
<jerith>
They're in the language because there are places where they're useful, but that's generally when you're dealing with things that have a specific reason to be mutable.
<gjaldon__>
jamesst20: you can have mutable state when you use `ref`s and mutable data structures in OCaml such as Arrays
<octachron>
jamesst20, no "=" is always "=="
<jerith>
jamesst20: On the contrary, "=" is an equality check pretty much everywhere except in "let" blocks or record construction.
<jamesst20>
octachron: except in a declaration right? Like let x = 5;;
<jamesst20>
Alright
<jerith>
And in those cases they mean "bind", not "assign".
<jamesst20>
jerith: Should List.iter be avoided asweel?
jnavila_ has joined #ocaml
<jerith>
jamesst20: What is the return type of List.iter?
<gjaldon__>
jamesst20: you only use List.iter if you want to do 'side-effects' for every element
<jamesst20>
jerith: I was thinking it was unit
<jerith>
(Looking at the types of things is very often a good way to reason about them in functional languages.)
<jamesst20>
jerith: Or just a shortcut to a for-loop
<jerith>
jamesst20: Exactly. That means that List.iter doesn't return any useful value.
<jamesst20>
# List.iter;; - : ('a -> unit) -> 'a list -> unit = <fun>
<jerith>
Compare that to List.map which returns "'b list".
<jamesst20>
jerith: So what is a good way to loop if not list.iter ? A recursive method?
<jamesst20>
jerith: Or a recursive match?
<jerith>
So you can use List.map to make a new list with things in it, based on an existing list.
<jamesst20>
gjaldon__: You mean edit all values?
<jerith>
If you only care about side effects (such as "print some stuff on the screen"), List.iter is what you want.
<jamesst20>
jerith: But can you assign it to a var that was declared before?
<jamesst20>
jerith: I am not sure to understand what means "side effects"
<jerith>
jamesst20: It's not really helpful to think about "assignment" in OCaml.
<haesbaert>
jamesst20: the way you look depends on the return you want: do you want a list (one kind of loop), do you want a member of the list (another), and so on.
<jerith>
What "let" does is "bind", not "assign".
<haesbaert>
jamesst20: make a function that prints all elements of a list, those are side effects, since it returns nothing.
<haesbaert>
"printing" is a side effect
<jamesst20>
So when something returns unit, it's basically a side effect if it has done something?
<haesbaert>
yes, otherwise the function would do nothing
<jamesst20>
Alright, so basically, side effect = actions that don't affect any vars
<jerith>
"let x = 5 in <expr>" means "evaluate <expr> using the value 5 wherever the name x appears".
<gjaldon__>
modifying mutable state is also a side-effect
<jamesst20>
gjaldon__: Alright didn't know that
<haesbaert>
side effect is anything that happens, that changes state that is not expressed in the return of a function
<gjaldon__>
jamesst20: a ‘side-effect’ is basically anything a function does besides returning a value
<gjaldon__>
what haesbaert said
<jamesst20>
jerith: Thanks for the tip. Before I came in this channel I was thinking it meant "declare this var, and continue runing code after in" I was so wrong
<jamesst20>
Alright thank you :)
<haesbaert>
jamesst20: The Little Schemer, although not an ocaml/ml book, really helped me think in functional terms
<octachron>
jamesst20, to understand the name side-effect, take a function f, it maps a input to an output: input ↦ output, in a pure functional world, that is all that function does
<haesbaert>
I'd advice to master List, if you understand iter X map X find X fold, it's a good start
paileyb has joined #ocaml
<octachron>
anything else that happens during the computation, like modifying the state of the world, happens on the "side" of the computation
<jamesst20>
There is something I still don't understand. How do you get to end up with a return value that you computed if everything is immutable
<jerith>
Side effects are very important, but they make programs hard to reason about.
<jerith>
jamesst20: Consider addition.
<jamesst20>
Are list mutable or immutable?
AlexDenisov has joined #ocaml
<jerith>
1 + 2 is an expression that evaluates to 3.
<octachron>
jamesst20, take a classical mathematical function f= x ↦ x², you can compute "f 2" and obtains 4 without modifying the value of 2 or any other values
<jerith>
All three of those numbers are immutable, but it's still possible to define a function that adds numbers together.
<jerith>
You can't modify immutable data, but you can certain create new data based on it.
<jamesst20>
jerith: I mean, let's say I have a list of numbers, that contains 0 to 9. I want to make a list that contains only 1 element out of 2. Like index 0, 2, 4,6,8
bobbypriambodo has quit [Ping timeout: 255 seconds]
<jamesst20>
jerith: how can my loop skip one element and add an element
<octachron>
jamesst20, let's call this function "odd"
<jamesst20>
Sure haha, I just meant an example
MercurialAlchemi has joined #ocaml
<jamesst20>
That was simple at least
<octachron>
the functional way would be to answer the question what is "odd []" ?
<haesbaert>
jamesst20: you want a new list that is a subset of the old list right ? So it's something with List.filter.
<jamesst20>
octachron: let odd tab = ... return a list with one element out of 2 of tab
malina has joined #ocaml
<jerith>
There are a bunch of different ways to implement that, and it's worth thinking about several of them.
<jamesst20>
haesbaert: But let's say I don't want to use the built in filter for that example
<jerith>
As haesbaert said, the eay way is to use List.filter.
<haesbaert>
this is step 2, step 1 is understanding how the api works
<haesbaert>
step 2 is implementing the the api
<haesbaert>
because once you get the API mechanics, you'll understand what should be written how
<haesbaert>
don't try to develop the API yourself at the beggining.
<jerith>
octachron is starting you on the recursive approach.
<haesbaert>
I suggest this; use List.filter, then write your own filter function and replace, then try something else.
<octachron>
which is: ask yourself what is "odd [a]"? odd [a;b] ? "odd a :: b :: rest" ? once you have the answer, you have more or less written the code
slash^ has joined #ocaml
<jamesst20>
haesbaert: I asked this example to answer a question I asked before. If I use the API, it won't answer. Let's consider we only add element where x mod 2 = 0
<jamesst20>
The question was "There is something I still don't understand. How do you get to end up with a return value that you computed if everything is immutable"
<jamesst20>
Would be doable with a match I guess?
<jerith>
jamesst20: I think a more interesting variant of that is the one octachron is getting at, which is "keep alternate values".
<haesbaert>
it starts witha match yes, and then it recurses into two cases : case 1 - add this element to the list I'm building. case 2 - skip this element to the list I'm building
<jamesst20>
haesbaert: What I don't undersdtand is the "add part", we can't just add an element if the element is immutable ?
<haesbaert>
if (odd x) then build x :: tail else build tail
<paileyb>
Hi all, sorry to interrupt. Compilation quirk question: say I have x.cmi and x.ml. ocamlc -c x.ml will overwrite x.cmi (exposing all of x). However if I `touch x.mli` then ocamlc -c c.ml will not overwrite x.cmi (and will use the signature in x.cmi). Why is this? You don't actually need the original mli, just an empty file.
<jamesst20>
jerith: Yeah this would be the output :)
<jamesst20>
haesbaert: Thank you :)
<haesbaert>
jamesst20: this kind of stuff is really well explained in the little schemer btw
<jerith>
jamesst20: Start as octachron suggested. What is "f []"?
<octachron>
paileyb, just the compiler assuming that you don't have a cmi file if you do not have a mli file
<paileyb>
octachron: Sure. It just seems strange that it wouldn't recognize the cmi file first. It's just a minor annoyance I guess, but I was curious if there was a good reason why the compiler behaved this way
<jerith>
jamesst20: Perhaps even start writing the function: "let f mylist = match mylist with | [] -> ..."
AlexDeni_ has joined #ocaml
AlexDenisov has quit [Read error: Connection reset by peer]
<octachron>
paileyb, since the compiler have no way to know that your cmi file stems from an external mli file, it seems reasonable to assume that it stems from the ml being compiled
<jerith>
That won't compile because the match isn't exhaustive, but you can (temporarily!) add '| _ -> failwith "not yet implemented"' to the end.
<octachron>
so recompiling the cmi file is sensible from the compiler perspective
<paileyb>
octachron: Yea, that makes sense. I guess I just had different expectations about what the compiler should be able to infer! Thanks!
<octachron>
paileyb, you are welcome. Another point is that the synchronisation between compiled interface and implementation is important for the safety of generated programs
<octachron>
it makes therefore sense to be conservative here
<jerith>
jamesst20: Then add cases one at a time (for [x] and [x; y] as octachron suggested) until you reach the point where you can generalise.
bobbypriambodo has joined #ocaml
<jamesst20>
Alright :)
<paileyb>
octachron: Yea that was the problem I was running into. Upon linking it all it was complaining about inconsistent interfaces. Took me a while to realize that the cmi file I thought was being used was actually being replaced.
bobbypriambodo has quit [Client Quit]
bobbypriambodo has joined #ocaml
vicfred has joined #ocaml
pyx has joined #ocaml
Twister_ has joined #ocaml
<Twister_>
hi !
pyx has quit [Client Quit]
govg has joined #ocaml
<Twister_>
Is there a french ( would be easier to understand ) to help me out with something ?
<lyxia>
Twister_: you can join #ocaml-fr
slash^ has quit [Read error: Connection reset by peer]
jamesst20 has quit [Quit: Thank you to everyone for the help]
bobbypri` has joined #ocaml
bobbypriambodo has quit [Ping timeout: 260 seconds]
MercurialAlchemi has quit [Ping timeout: 240 seconds]
MercurialAlchemi has joined #ocaml
paileyb has quit [Quit: Page closed]
bobbypri` has quit [Remote host closed the connection]
bobbypri` has joined #ocaml
freusque has joined #ocaml
frefity has joined #ocaml
dch_ has joined #ocaml
Simn has joined #ocaml
<dch_>
b
<dch_>
nhjh
<dch_>
m
<dch_>
ummmmj
<dch_>
hjghgjuj3333333333333333333333333
<jerith>
Hello dch_'s cat. :-)
<dch_>
it seems my children will be learning ocaml from now on :-)
<jerith>
Hello dch_'s children, then. :-)
dch_ has quit [Ping timeout: 240 seconds]
SomeDamnBody has joined #ocaml
bobbypri` has quit [Ping timeout: 240 seconds]
<SomeDamnBody>
So, I have a decision tree that I want to build. Some nodes are choices, and some are just intermediary points between other choices.
<SomeDamnBody>
Is there something that would help me accomplish that is already build somewhere?
Abso has joined #ocaml
<Abso>
Hey I am a total OCaml beginner and I stumbled across a % operator, but I can't seem to find what it does. My guess is that it is some kind of function composition?
<kakadu>
It is not defined by default
<kakadu>
Abso: waht is the context?
<Abso>
oh I see, now I am just wondering what it does
SomeDamnBody has quit [Remote host closed the connection]
MercurialAlchemi has quit [Ping timeout: 240 seconds]
foo30303 has quit [Ping timeout: 260 seconds]
foo30303 has joined #ocaml
Onemorenickname has joined #ocaml
<Onemorenickname>
hello people
<Onemorenickname>
how can i express that a function, when applied to a type "grammar" has result "grammar", and that when applied to a type "cgrammar", has result "cgrammar" ?
foo30303 has quit [Read error: Connection reset by peer]
<kakadu>
Do you want ad-hoc polymorphism?
<Onemorenickname>
kakadu, no, it's the same implementation
<Onemorenickname>
my function has type "grammar -> grammar & cgrammar -> cgrammar"
<Onemorenickname>
but I don't know how to write that in ocaml
<Onemorenickname>
or to emulate that
<Onemorenickname>
(without copy-pasting the code)
<kakadu>
if type cgrammar equals type grammar it will be easy :)
<Onemorenickname>
it's not
foo30303 has joined #ocaml
<kakadu>
How much different they are?
<kakadu>
Because the default solution is to create a new datatype with two constructors
<Onemorenickname>
how would that solve the problem ?
<Onemorenickname>
i'd still have to write the same code twice
<kakadu>
Your task can be unsolvable when grammar = int and cgrammar is string
<kakadu>
I don't have enough information to answer your question
<zozozo>
Onemorenickname: well obvisoulsy grammar and cgrammar share some structure, and I guess that is the structure that your function operates on, so a solution would be to factor the two type definitions so that type grammar = foo t and type cgrammar = bar t for some types foo, bar and t, and then have a function of type 'a t -> 'a t ?
<Onemorenickname_>
as i don't know how to express the type I want
<Drup>
You can't express the type you want, this sounds like a decent solution to me
<Drup>
or, alternatively, ([< grammar] as 'a) -> 'a -> 'a
<Onemorenickname_>
but combinator is not [< grammar]
<Onemorenickname_>
combinator_grammar *
<Drup>
hum, actually, no, that doesn't work because of recursion
<Onemorenickname_>
is there some kind of macro system in ocaml ?
<Drup>
Not any that would solve this probel
<Drup>
problem*
<Onemorenickname_>
so I can automatically add functions "_grammar" and "_cgrammar" with the correct types automatically ?
<Drup>
and anyway, I don't think this should be a problem
AlexDeni_ has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
<Onemorenickname_>
hm
<Drup>
You're only duplicating some type in the .mli, it's really not that terrible
<Onemorenickname_>
i have a lot of such functions
<Drup>
you could play with having a recursive polyvar type that is a subtype of both grammar and cgrammar
<Drup>
but I think the biggest result is going to be making knots in your and your user's brain
<kakadu>
:-)
djellemah_ has quit [Ping timeout: 268 seconds]
freusque has quit [Ping timeout: 255 seconds]
ygrek has joined #ocaml
<Onemorenickname_>
Drup : there are bigger knots if I have to track down the type of every grammar I use to know if it's a grammar or a cgrammar and use the function_grammar or the function_cgrammar
rpg_ has quit [Read error: Connection reset by peer]
rpg has joined #ocaml
<Onemorenickname_>
I may drop some static typing correctness, make everything a cgrammar, and test if the cgrammar has any non-grammar member left before parsing
<Drup>
then look at the type infered for sep_mul and expose that :)
<Onemorenickname_>
Drup : oh.
<Drup>
(it'll give you the recursive polyvar type I talked about earlier)
<Onemorenickname_>
it will be too general, but I won't lose the static typing properties
<Onemorenickname_>
hmhmhmhmhm
<Onemorenickname_>
sounds good enough!
Muzer has quit [Ping timeout: 256 seconds]
kakadu has quit [Remote host closed the connection]
larhat has quit [Quit: Leaving.]
Muzer has joined #ocaml
tane has quit [Quit: Leaving]
jnavila_ has quit [Remote host closed the connection]
foo30303 has quit [Ping timeout: 255 seconds]
Onemorenickname has joined #ocaml
Onemorenickname_ has quit [Ping timeout: 255 seconds]
dch_ has joined #ocaml
TheLemonMan has quit [Quit: "It's now safe to turn off your computer."]
sepp2k has quit [Quit: Leaving.]
foo30303 has joined #ocaml
simon3 has joined #ocaml
dch_ has quit [Quit: ZZ]
dhil has joined #ocaml
rcsole has quit [Ping timeout: 255 seconds]
rpg has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
rpg has joined #ocaml
dhil has quit [Ping timeout: 240 seconds]
jao has joined #ocaml
orbifx has joined #ocaml
foo30303 has quit [Remote host closed the connection]