<pippijn>
gasche: because no build system does what I need
<ygrek>
wmeyer, did you start anything on ocamlbuild library front?
<pippijn>
do you think there is a build system that does?
<pippijn>
I would love to hear about it
<pippijn>
I need composition of projects
mcclurmc has joined #ocaml
<wmeyer>
ygrek: hi, no I've not started yet, I may at some point
<pippijn>
that's where most build systems already fail
* ygrek
thinks the more half-broken build systems - the better!
<ygrek>
that is so fun to discover different ways to break things in unusual environment
<ygrek>
and not that I am completely satisfied with existing ones :)
<wmeyer>
:-)
<wmeyer>
but OMake does it in a very exceptional way
<ygrek>
wmeyer, ok, I hope I will not have to start it before you do :))
<wmeyer>
fails, in the end
<gasche>
pippijn: did you look at whether those build system could be fixed?
milosn has joined #ocaml
<pippijn>
gasche: yes, I tried very hard to get omake to work
<wmeyer>
ygrek: feel free actually, I welcome any good patches
<gasche>
re. ocamlbuild, the myocamlbuild.ml part is not modular yet (but we have some ideas to solve that and would love someone lending a hand)
<pippijn>
gasche: I also tried very hard to make automake work
<gasche>
but the _tags part is, I believe
<pippijn>
I haven't tried ocamlbuild
<gasche>
pippijn: there are also ocp-build (no idea how it works, for all I know it hasn't been officially announced)
<ygrek>
wmeyer, I prefer the lazy approach, wait until it bites me hard, then discover that it was already done by somebody else..
<gasche>
and some redo-inspired build system
<pippijn>
I like a build system that has no built-in rules
<wmeyer>
pippijn: automake has a nice tasty M4 macros
<pippijn>
one where all rules are defined in a standard library of rules
<wmeyer>
ygrek: :-)
<pippijn>
ocamlbuild has a lot of magic
<pippijn>
ocamlyacc, menhir, ocamlc magic
<gasche>
I'm not sure what you mean
<pippijn>
for example the output
<pippijn>
it will say something like "compiling foo.ml" or so
<wmeyer>
pippijn: these are not built in rules though, these are defined somewhere but are regural rules
<gasche>
but ocamlbuild did start with a non-ocaml-specific build system design
<pippijn>
you can't do that as myocamlbuild
<gasche>
(later features and bugfixes may have hard-coded some OCaml-specific logic, though)
<gasche>
pippijn: you mean the text output cannot be tweaked by the user?
<gasche>
because if you write rules to build .java files, it will say "compiling foo.java" as well; that's not OCaml-specific I think
Simn has joined #ocaml
<wmeyer>
right, time to go to woark!
<pippijn>
no
<pippijn>
gasche: it will show the command
<pippijn>
at least it was like that when I used it
milosn has quit [Ping timeout: 246 seconds]
<pippijn>
when the command becomes long, the output is useless
<gasche>
hm
<wmeyer>
pippijn: ocamlbuild has sane architecture, but the problem is, completely unsuitable at the moment for the big projects like Coq
<wmeyer>
OMake would handle them without hitch
<gasche>
wmeyer: you mean performance-wise, or flexibility-wise?
Kakadu has joined #ocaml
<wmeyer>
gasche: purely performance, because I appreciate ocamlbuild for flexibility. (although experiment with OCaml was not entirelly success)
<gasche>
at some point in time I would be interested in having a look at the performance issues
<gasche>
(well if nobody works on that first)
<wmeyer>
yes, please do
<gasche>
do you know what kind of repro-case I should use to measure potential improvements?
<wmeyer>
you will be blessed by Coq team, if you make it asymptoticaly like GNU Make in Coq case
<gasche>
eg. I heard avsm say "building mirage is slow", but I'm not sure where to start to actually try building mirage, or if that's even a good test-case
<gasche>
wmeyer: does Coq have an ocamlbuild machinery in place right now?
<wmeyer>
it does
<gasche>
ok
<gasche>
so a good, measurable objective would be "make compilation of Coq faster"
<wmeyer>
yeah
<wmeyer>
it's not easy though!
<wmeyer>
have fun :-)
<gasche>
have you looked at the question? eg. do you know what the lowest-hanging fruits are?
<wmeyer>
I don't remember, but I may have a look and update the mantis
<gasche>
I think ygrek looked at that as well
<wmeyer>
the ones that are worthwhile where pointed by ygrek and patches were given
<gasche>
yeah
<wmeyer>
I incorporated some of them
chrisdotcode has quit [Read error: Connection reset by peer]
milosn has joined #ocaml
<wmeyer>
actually, I can say it's possible that 80% of these performance problems are fixable in some constant time
<ygrek>
IIRC one can call ocamlbuild with empty set of rules
<ygrek>
and then define custom ocaml rules on top
ontologiae_ has joined #ocaml
<wmeyer>
but the 20% are difficult due to the nature of ocamlbuild
<ygrek>
I guess for 99% of users those custom rules will be more broken than default ones
<ygrek>
but you can have "compiling x.ml"!! and ponies!!!
<ygrek>
well.. maybe
<wmeyer>
ocamlbuild actually runs the code during the dependency discovery, so it's not possible to do global analysis
<ygrek>
wmeyer, iirc, those 20% have to deal with the dynamic dependency dsicover
<ygrek>
correct :)
<wmeyer>
:-)
<ygrek>
so you have either to special case branches without dynamic deps and run them in parallel next time
<wmeyer>
but ... you can make them optionally less dynamic
<ygrek>
or somehow do some magic
<wmeyer>
and be conservative
<wmeyer>
one would need to look how to transform the existing rules to static ones
<ygrek>
that's an interesting piece of work
<wmeyer>
i think it's a serious design bottlenec
<wmeyer>
the other option is to do dry run
<wmeyer>
because every rule has set of dependencies and productions
<ygrek>
btw, one painful thing is compiling ocamlbuild - I do not know other way as whole ocaml make - and it takes some time building (or checking) some other things
<ygrek>
can it be avoided?
<wmeyer>
it would be possible (not in general case) to run the rules without calling tools
<wmeyer>
ygrek: most certainly yes, and actually that's what I'd advise for gasche to look at first
<gasche>
I have been thinking about dynamic dependencies
<gasche>
(but keep in mind that I don't know the ocamlbuild details yet)
<gasche>
I think one thing that could work is to record, from one build to the next, which discoveries worked
<gasche>
and optimistically replay those in priority
<ygrek>
wmeyer, I thought you know the way because you are our ocamlbuild god now :)
<wmeyer>
so, I have to say, I am almost convinces we can build Coq in sane time with ocamlbuild
<ygrek>
and that 80/20 pareto breakdown is once again amazing
<wmeyer>
if I was I'd be blessed by Coq team ygrek :-)
ben_zen has quit [Ping timeout: 246 seconds]
zpe has joined #ocaml
<ygrek>
gasche, yes, that's exactly what I thought when stumbled accross it
eikke has quit [Ping timeout: 248 seconds]
eikke has joined #ocaml
<gasche>
ygrek: what's your professional activity? is there any way
<gasche>
you could ask funding from, say, ocamllabs, to work on ocamlbuild?
<wmeyer>
right guys, it seems like you have better ideas than me, please continue disussions, and I will go to continue my day time job :-)
<wmeyer>
good patches to ocamlbuild are always very welcome
<gasche>
(I have no idea whether they would be interested in paying for that; the first question is whether you would be interested in working on that)
zpe has quit [Ping timeout: 256 seconds]
<Kakadu>
I have reached some problems with compiling. Can overwriting .cmi file while library installation cause the problem? http://paste.in.ua/8439/
<gasche>
Kakadu: my guess would be that the "ocamlfind install" command has those files several times
<gasche>
there must be a way to ask setup.ml to be more verbose to show the command to check that
<gasche>
but then you'll have to find out how this command is generated and why it fails
<gasche>
(did you mention this module twice in the _oasis file?)
<Kakadu>
No, it is not my library but ocsigen's
<Kakadu>
and this module appears twice
<Kakadu>
$ find . -name eliom_widgets.cmi
<Kakadu>
./_build/src/_client/eliom_widgets.cmi
<Kakadu>
./_build/src/_server/eliom_widgets.cmi
<Kakadu>
I rpobably should report it to developer
<ygrek>
gasche, I do ocaml full-time every day and usually I do some tangentially related opensource work at job hours, when there is time :)
<gasche>
Kakadu: yeah, just report it upstream
<gasche>
I don't know whether ocamlfind support subdirectories in the install location, so it may be an issue
<pippijn>
wmeyer: why doesn't oasis use the same way?
<pippijn>
wmeyer: I don't see much reason for a DSL just to describe data
<pippijn>
maybe it's slightly prettier
<pippijn>
ok, maybe the error messages are better
weie_ has joined #ocaml
weie has quit [Ping timeout: 246 seconds]
mort___ has quit [Ping timeout: 276 seconds]
zpe has quit [Ping timeout: 264 seconds]
Kakadu has quit [Remote host closed the connection]
Kakadu has joined #ocaml
Kakadu has quit [Remote host closed the connection]
Kakadu has joined #ocaml
Kakadu has quit [Remote host closed the connection]
Kakadu has joined #ocaml
pootler_ has quit [Ping timeout: 246 seconds]
pootler has quit [Ping timeout: 248 seconds]
mcclurmc has quit [Ping timeout: 246 seconds]
<Kakadu>
Do you know will RWO have a chapter about camlp4?
beckerb has joined #ocaml
zpe has joined #ocaml
weie has joined #ocaml
introom_ has joined #ocaml
wagle_ has joined #ocaml
bholst_ has joined #ocaml
mcclurmc has joined #ocaml
Khady has quit [Ping timeout: 260 seconds]
Armael has quit [Ping timeout: 260 seconds]
josch_ has joined #ocaml
rednovae_ has joined #ocaml
spearalo1 has joined #ocaml
hyperbor1ean has joined #ocaml
jlouis_ has joined #ocaml
ulfdoz_ has joined #ocaml
avsm_ has joined #ocaml
tizoc` has joined #ocaml
asmanur_ has joined #ocaml
zpe has quit [Ping timeout: 248 seconds]
thomasga1 has joined #ocaml
weie_ has quit [*.net *.split]
introom has quit [*.net *.split]
thomasga has quit [*.net *.split]
ulfdoz has quit [*.net *.split]
testcocoon has quit [*.net *.split]
def-lkb has quit [*.net *.split]
pango has quit [*.net *.split]
asmanur has quit [*.net *.split]
hyperboreean has quit [*.net *.split]
spearalot has quit [*.net *.split]
wagle has quit [*.net *.split]
tizoc has quit [*.net *.split]
mathieui has quit [*.net *.split]
rednovae has quit [*.net *.split]
josch has quit [*.net *.split]
bholst has quit [*.net *.split]
jlouis has quit [*.net *.split]
avsm has quit [*.net *.split]
avsm_ is now known as avsm
ulfdoz_ is now known as ulfdoz
cdidd has joined #ocaml
q66 has joined #ocaml
def-lkb has joined #ocaml
testcocoon has joined #ocaml
mathieui has joined #ocaml
Kakadu has quit [Remote host closed the connection]
Kakadu has joined #ocaml
<pippijn>
hum
<pippijn>
let targets = [
<pippijn>
#use "makefiles.ml"
<pippijn>
]
<pippijn>
this doesn't work?
<adrien_oww>
I'd expect that #use ends the file with ";;"
<adrien_oww>
rather
<adrien_oww>
that it expects a full, working, sentence
<pippijn>
I see
<pippijn>
ok then
osa1 has quit [Ping timeout: 246 seconds]
Neros has joined #ocaml
eikke has quit [Ping timeout: 260 seconds]
zpe has joined #ocaml
csakatoku has joined #ocaml
introom_ has quit [Remote host closed the connection]
csakatok_ has quit [Ping timeout: 245 seconds]
zpe has quit [Ping timeout: 256 seconds]
pootler has joined #ocaml
thizanne has quit [Ping timeout: 246 seconds]
kaustuv has joined #ocaml
pootler has quit [Ping timeout: 248 seconds]
introom has joined #ocaml
Khady has joined #ocaml
zpe has joined #ocaml
<Kakadu>
I have a syntax extension file for camlp5 and I want to add printing when it enters to some functions. I execute `make && camlp5o pa_ostap.cmo pr_o.cmo test.ml` to test. No any my printing is in the output.
<Kakadu>
Have I added prints to unused functions or thigs are more complex? Does it prints new ocaml source to the stdout or to some another stream?
<kaustuv>
gasche: Francois does not like my modifications to pprint, so pointing them to that github page is probably a bad idea
ericfr has quit [Remote host closed the connection]
<gasche>
hmpf
<kaustuv>
basically he thinks parenthesization is orthogonal to 2-d layout (which is a fair point), so the two need not be combined in the same library
<gasche>
how would you layer two libraries to get both?
<gasche>
you could have your library do a (AST => AST + extra parens) pass, then use pprint?
<gasche>
(but PPrint already had combinators for ML-like printing of values, so I thought that could fit in that category of "optional convenience layer on top of the core combinators")
<kaustuv>
well, I think his point is that the parenthesization did not need to touch the core (PPrintEngine and PPrintCombinators), so it can be glued on from outside the library
<kaustuv>
and can even be made functorial over formatting libraries, so e.g. it can also work with stdlib's Format
<gasche>
with a (AST => AST+parens) pass, you can compose parenthezing and pretty-printing, instead of make one depend on the other (even generically)
<gasche>
hm
<kaustuv>
On an unrelated note, I was reading RWO last night and found that it doesn't explain the main "edit-test-debug" loop of OCaml enough. I've therefore updated some of my ancient course handouts to modern OCaml and put it online here: http://chaudhuri.info/misc/osetup/ -- suggestions welcome!
<companion_cube>
oh, you do have a "debug" phase in your cycle? 0:-)
<gasche>
kaustuv: have you tried Merlin?
travisbrady has joined #ocaml
<gasche>
(I'm asking because your .ocamlinit file looks interestingly similar to .merlin information)
eikke has quit [Ping timeout: 248 seconds]
<gasche>
(I've been wondering about how to factorize all those small configure files across various ocaml tools lately)
snearch has joined #ocaml
eikke has joined #ocaml
ollehar has quit [Ping timeout: 246 seconds]
dezzy has quit [Quit: leaving]
Kakadu has quit []
zpe has joined #ocaml
<kaustuv>
companion_cube: my "debug" phase is "run things at the toplevel and see what happens"
<kaustuv>
gasche: no, I've never even heard of .merlin
<companion_cube>
kaustuv: aww, you're breaking the myth of "if it compiles, it works" ^^
<kaustuv>
that's a stupid myth
<gasche>
companion_cube: you didn't pay attention to my talk :-'
<whitequark>
all of its data structures are actually parameterized by 'loc and 'value, and that kind of works
<whitequark>
but it doesn't for exceptions
<whitequark>
I guess I should use a functor here?
<kaustuv>
whitequark: unfortunately, OCaml does not have polymorphic exceptions
<kaustuv>
So you have to move 'loc and 'value to module-level types and functorize
<whitequark>
though
<whitequark>
it occured to me that I can just move it around :)
<whitequark>
hm no, I cannot
<gasche>
I think polymorphic exceptions would be unsound, because there is no typing information flowing from the raise site to the catch site
<whitequark>
can I define mutually recursive types and modules?
<gasche>
kaustuv: Merlin is like Coq General for OCaml
<gasche>
I personally much prefer to use Coq General than interacting with coqtop directly
<whitequark>
type foo = ... and module Foo = Foo_bar(foo)
<whitequark>
something like that
<gasche>
but of course for dynamic aspects, a toplevel is still useful
<kaustuv>
gasche: Standard ML has polymorphic exceptions, so they can be sound in principle.
<gasche>
I'm not sure we are seeing the polymorphism in the same place
<kaustuv>
Right, the exn type itself is not *parametrically* polymorphic
<kaustuv>
So there will be some existential wrap/unwrap magic going on
<gasche>
do you have an SML example of what you mean?
<gasche>
it's surprisingly hard to find to-the-point information about SML online, due to it being contained in a book
<kaustuv>
Sure, the standard function of type unit -> ('a -> t) * (t -> 'a option) can be defined in SML with t = exn
<gasche>
you can also do that with local exceptions in OCaml, but I don't remember if that is since 3.12 or 4.00
<kaustuv>
If I remember my SML syntax right (a bit rusty): fun 'a make : unit -> ('a -> t) * (t -> 'a) = fn () => let exception E of 'a fun inj x = E x fun proj (E x) = SOME x | proj _ = NONE in (inj, proj) end
<gasche>
let embed (type a) () = let module M = struct exception E of a end in (fun x -> M.E x), (function (M.E x) -> Some x | _ -> None);;
<gasche>
the key is the use of a local type constructor, instead of a type variable
<gasche>
(but I don't think even SML would support parametrized exceptions as asked by whitequark )
<kaustuv>
I would say the key is that the type is quantified *outside* the exception. If it were quantiied in a different place (using standard let-polymorphism rules) then the exception would be useless
<gasche>
and yeah, using a local module to have local exceptions is a bit ugly
<ggole>
whitequark: types yes, modules no (afaik)
<gasche>
you can using recursive modules, but it's a door to ever-increasing complexity
<whitequark>
ggole: so I just flattened it to the module which was using it
<whitequark>
figured it was easiest.
<whitequark>
it's rather intrinsically coupled anyway
<ggole>
You could also pass the relevant bits as arguments
<gasche>
just wrap everything in a recursive module and you can have recursivity across syntactic classes that don't have a shared "rec .. and" constructor
<kaustuv>
if by local you mean scoped, then the only use case I know for them is in things like pattern compilation
<kaustuv>
or maybe a poor man's shift/reset
<gasche>
the problem is that you are then bound by the limitations of recursive modules, which is a bit more surprising than what one may like
<gasche>
(because they ensure statically that there is no risk of non-termination when building the module(s))
<ggole>
Usually I want mutual recursion between modules in different files
<ggole>
Right
<gasche>
that's not supported
<ggole>
Figured that would be impossible
<gasche>
well
<kaustuv>
This is where I say my obligatory "it's possible in MixML"
<gasche>
we got tired of this debate but I read a F# blog post a few days ago about how it was actually a good thing to forbid cyclic dependencies
<ggole>
Eh? It's allowed for types and functions
<ggole>
In a directly anologous way!
<gasche>
I'm not claiming it is, I'm just reporting
<whitequark>
kaustuv: oh, thanks for link
<whitequark>
*reference
csakatoku has joined #ocaml
<ggole>
I guess there is no good place to put the analogue of 'and' for file-level modules.
<gasche>
kaustuv: I think the recent work by Jacques Garrigue, Keiko Nakata and Hyeonseung Im also tackles this, maybe in a more direct way
<ggole>
(Perhaps you would have to require all files be presented to the compiler at the same time?)
<gasche>
(I mean if you are interested in only adding more recursion to ML-modules-as-we-know-them, that's a better place to start looking)
<kaustuv>
I don't want recursion so much as mixins, and using recursion to express mixins is a bit heavyweight for my tastes
<gasche>
ggole: it should be possible to first define the mutually recursive interfaces in one file, and then use them as interfaces for separately-located modules
<kaustuv>
but I'll take a look at this recent work. Thanks for the pointer
<gasche>
of course MixML does mixins better :]
<gasche>
in fact
* ggole
nods
<gasche>
I regret that when you want mixins, you are forced to buy recursion as well
<pippijn>
why is that?
<gasche>
it's something that feels weird about MixML (besides the question of "should we also drop lambda-abstraction in the small and use mixins everywhere, then?")
<kaustuv>
well, the MixML paper probably goes a bit far in that respect. I don't necessarily want *all* my binding constructs to be expressed in the module language. I think they did it because of a sense of minimalism
<gasche>
pippijn: I'd say that the central idea of mixins is to avoid introducing a phase distinction between values and "what those values depend on"; no order between users and their dependencies
csakatoku has quit [Ping timeout: 276 seconds]
redfire has joined #ocaml
<gasche>
once you removed all order, it's natural to let cyclic define-use relations naturally happen
<gasche>
and the MixML work therefore doesn't tackle this part (restricting recursivity), which seems orthogonal
<kaustuv>
you don't remove *all* order. The mixin combinator is an ordered and
<gasche>
I need to re-read this work again
zpe has joined #ocaml
introom has quit [Read error: Connection reset by peer]
<gasche>
but logically I'm shocked by uncontrolled recursion
introom has joined #ocaml
<pippijn>
I don't get it.. before, constructing the rules and DAG took 4.3 seconds
<gasche>
(which doesn't mean it's a bad idea for a component system)
<pippijn>
now it takes a full second more
<pippijn>
I changed nothing besides adding a timer function
dezzy has joined #ocaml
<pippijn>
I removed them, no change, still 5.3 seconds
<hnrgrgr>
gasche: I add patch and bench in #4243
ollehar has joined #ocaml
<gasche>
hnrgrgr: thanks a lot; did you benchmark against 4.00 or trunk/4.01? I believe Camlp4 is now faster to compile
<gasche>
(at least it eats less memory)
<hnrgrgr>
4.01
<pippijn>
ok, I found something weird
<pippijn>
some functions are called up to 4 times
<pippijn>
I wonder if omake has function call trace..
zpe has quit [Ping timeout: 256 seconds]
<kaustuv>
Merlin is actually very interesting. Thanks a lot for the pointer. I might start using it regularly.
<gasche>
hnrgrgr: would you rather get reference by your name in mantis discussions, or your nickname?
<gasche>
kaustuv: it's still a bit young, but I'm sure the devs will appreciate any feedback/bugreport; as far as I know, there haven't been bugs reported in the last few weeks, which means it's stabilizing
oberonc has quit [Quit: Page closed]
introom has quit [Remote host closed the connection]
<hnrgrgr>
gasche: :) don't care.
kaustuv has left #ocaml []
ollehar has quit [Ping timeout: 248 seconds]
ben_zen has joined #ocaml
ben_zen has quit [Ping timeout: 268 seconds]
travisbrady has quit [Quit: travisbrady]
zpe has joined #ocaml
thizanne has quit [Ping timeout: 245 seconds]
<pippijn>
ok, down from 4.3 to 3.6
<pippijn>
one optimisation
<pippijn>
a common-case optimisation
zpe has quit [Ping timeout: 264 seconds]
<pippijn>
3.0
<pippijn>
I can't optimise any further, omake already needs 2.5 seconds to read the files and construct the DAG
<pippijn>
my code is fast now
<pippijn>
wmeyer: 3 seconds
<pippijn>
wmeyer: to read the makefiles and construct rules+graph
<pippijn>
wmeyer: 2.4 now
<pippijn>
(caching)
justdit has quit [Read error: Operation timed out]
ttamttam has joined #ocaml
wagle_ is now known as wagle
Neros has quit [Ping timeout: 246 seconds]
watermind has joined #ocaml
zpe has joined #ocaml
<watermind>
is there a name to denote a type which is a product or coproduct (but not functional nor primitive)
<watermind>
I thought structured type, but that includes functional types I think
<gasche>
positive type?
Neros has joined #ocaml
<watermind>
hmmm what would a negative type be?
<gasche>
hm
<gasche>
in fact "positive type" would be confusing
<watermind>
I've seen pos/neg denote positions in types
<gasche>
yes
<gasche>
and if you only have sums and products, you only have positive positions
<gasche>
but I don't understand your restriction to "not be primitive"; don't most types have primitive types at their leaves?
<watermind>
sorry didn't explain well
<gasche>
hm
<gasche>
are you talking of type declarations, or type expressions?
<watermind>
type expressions
<watermind>
and I mean to include e.g. (a->b) x c
<watermind>
or (a->b) + c
<gasche>
so you only want the head constructor to be a sum or a product
<watermind>
since first node is a x or a +
<gasche>
then "positive type" would be a reasonable choice in ML
Arsenik has joined #ocaml
<gasche>
but you would still need to explain the meaning
<watermind>
yes, for the case where the only constructors are + and x I've seen the designation "regular types"
<gasche>
(and they are negative intepretations of sums and products as well)
<watermind>
positive type should include primitive types though...
<gasche>
yes
<watermind>
I didn't mean to :/
ollehar has joined #ocaml
<gasche>
but what is bool if not unit+unit?
cago has left #ocaml []
Watcher7|off is now known as Watcher7
<watermind>
well it is in my case :P
<asmanur_>
polynomial types ?
<watermind>
and it is not primitive :P
<gasche>
so what's a primitive type?
<watermind>
hmm polinomial is interesting too
<gasche>
asmanur_: polynomials won't allow functions in depth
mika1 has quit [Quit: Leaving.]
<watermind>
in my case just int
zpe has quit [Ping timeout: 246 seconds]
<watermind>
the reason why I was looking for a name is this
<gasche>
can you not consider int a 2^32 sum of units?
<gasche>
(or ^64 of course)
<asmanur_>
gasche: yes but i thought functional were forbiddeen ?
<gasche>
asmanur_: only as the head constructor
<watermind>
not in my case, I really consider ints, as in all of them
<watermind>
the reason why I wanted this is just the following, I'm defining the grammar for types
<watermind>
I also want to define the grammar for ground types
<gasche>
(Types whose head constructor is a finite sum or product)
<watermind>
and I just wanted to avoid repetition in the definition
<watermind>
likewise for terms
<gasche>
why do you need to isolate those types in your grammar?
ben_zen has joined #ocaml
<watermind>
so one possibility would be to do, for instance... S[T] = TxT | T+T
<watermind>
and then just use that in the definitions... so T = Int | T->T | S[T] and G = Int | S[T]
<watermind>
here it doesn't save that much trouble, but then you also have values
<watermind>
so I basically I was trying to make the grammar for terms/types modular
<watermind>
and come up with names for each module
<gasche>
I'm curious as to why you need to pick precisely those two concepts
raichoo has quit [Quit: leaving]
<watermind>
well... I do need to distinguish between ground and non-ground types
<watermind>
ground being the non-computational values
<watermind>
and non-ground being those which are computational in nature
<watermind>
then when it comes to terms I need to distinguish values from non-values
<gasche>
in my mind "ground type" means "closed, with no free variables"
<watermind>
really?
<watermind>
so ground type is something you'd only use in a context where you have polymorphism?
<gasche>
some form of type variables at least
thizanne has joined #ocaml
<watermind>
hmmm
<gasche>
unfortunately google "ground type" is all about Pokemon
<companion_cube>
:D
<watermind>
same
<watermind>
>/
<companion_cube>
duck-typing is old, pokemon-typing is the new trend
<companion_cube>
try google scholar?
<gasche>
in fact I think it depends on the communities
<gasche>
in any context "ground" means "the simple kind"
<companion_cube>
to me, "ground" means "no variables"
<gasche>
I've read more type inference / ML-polymorphism paper than others, so to mean it means "closed"
<gasche>
yep
<gasche>
ah yeah, without quantifiers inside as well
ygrek has quit [Ping timeout: 256 seconds]
<companion_cube>
indeed (although I do first order)
<watermind>
you're right
<watermind>
damn
<gasche>
in some contexts, "ground types" can also be used to mean "base type", like type constants in simply-typed lambda-calculus
<watermind>
so, if you have T = Int | TxT | T+T | T->T what do you call the subset S = Int | SxS | S+S
<gasche>
without arrows in depth?
<watermind>
yes
<gasche>
polynomial would be ok then
<watermind>
that makes sense... but then would the values be polinomial values?
<watermind>
:/
<gasche>
(there is an existing body of work on "polynomial functors", which are related to "strictly positive" parametrized types; see, positivity again)
<companion_cube>
I'd say "constants"
<watermind>
constants seems good until I want to talk about the respective terms
<watermind>
x : int x Int would be a constant variable
<gasche>
you could say non-functional values
<gasche>
though the parallel is not clear
<gasche>
I would say "positive values", I think
<watermind>
I was using non-functional to include arrows at deeper levels
<gasche>
seems weird
<watermind>
I was trying to avoid pos/neg because I do have pos/neg in the semantics
<watermind>
so I will have these types in negative positions at times
<gasche>
you could say "positive values" for values of polynomial types, and head-positive values for those having only a positive head constructor
<gasche>
well you can speak about positive types in negative positions
<watermind>
true...
<gasche>
(in focusing-inspired domains, "negative" can also sometime mean "lazy")
<gasche>
(so there would be a notion of "negative sum" and "negative product" being more or less the lifted sum and product types of Haskell)
<gasche>
(but I think you would want to rule out those as well, if you had them in your language)
<watermind>
it's all strict in my case...
<gasche>
in common strict languages, only arrows are negative
<watermind>
yeap
<watermind>
by the way, going a bit on a tangent is there some somewhat standard way to denote (mathematically) a weak coproduct
<watermind>
as in opposed to Σ which denotes a strong coproduct
<watermind>
s/indexed sum/coproduct
ttamttam has quit [Ping timeout: 252 seconds]
<gasche>
Coq has weak sums and still uses Σ, I think
<gasche>
some people use \exists, but that's a bit dangerous
<watermind>
I'll be using both... strong and weak... you can allways tell from context which it is because they live in different domains
<watermind>
but still you can get both in the same expression, so it makes it somewhat weird
oriba has joined #ocaml
<gasche>
maybe add a tilda on the weak one?
<watermind>
I was thinking about maybe using Σ_[i \in A] S_i with the [ ] denoting that you can have either i or (i,s) with s in S_i
<watermind>
gasche: ~ <-
<watermind>
on top?
<watermind>
could work
zpe has joined #ocaml
<gasche>
you could also play with notations
<gasche>
some people use (i:A) * S_i for strong dependent sums
<gasche>
(and (i:A) -> S_i for dependent product)
<watermind>
right, Agda like
<gasche>
that notation clearly doesn't work for weak sum
<gasche>
so you can use Σ for those
<gasche>
but that's a bit vicious
mcclurmc has joined #ocaml
snearch has quit [Quit: Verlassend]
<pippijn>
wmeyer: 1.7 seconds
zpe has quit [Ping timeout: 240 seconds]
<pippijn>
ah no
<pippijn>
wmeyer: never mind that, I disabled a whole part of the tree
hkBst has quit [Quit: Konversation terminated!]
travisbrady has joined #ocaml
ygrek has joined #ocaml
ollehar has quit [Ping timeout: 276 seconds]
<watermind>
I think I'll go with value types / computational types
<orbitz>
Anyone know how to license software? Is it sufficient to drop the license in the root dir? I'm not sure what license to choose...
zpe has joined #ocaml
ygrek has quit [Remote host closed the connection]
redfire has quit [Quit: WeeChat 0.4.0]
ygrek has joined #ocaml
ollehar has joined #ocaml
zpe has quit [Ping timeout: 245 seconds]
darkf has quit [Quit: Leaving]
skchrko has quit [Quit: Leaving]
eikke has quit [Ping timeout: 276 seconds]
raichoo has joined #ocaml
mcclurmc_laptop has joined #ocaml
justdit has joined #ocaml
tizoc has quit [Changing host]
tizoc has joined #ocaml
oriba has quit [Quit: oriba]
mcclurmc has quit [Ping timeout: 240 seconds]
zpe has joined #ocaml
justdit has quit [Read error: No route to host]
travisbrady has quit [Quit: travisbrady]
osnr has quit [Quit: Leaving.]
dsheets has quit [Read error: Operation timed out]
ygrek has quit [Ping timeout: 256 seconds]
zpe has quit [Ping timeout: 268 seconds]
mcclurmc_laptop has quit [Ping timeout: 240 seconds]
tianon has quit [Quit: "I'm a very important man. I've got a tower!"]
wagle has quit [Read error: Connection reset by peer]
UncleVasya has quit [Read error: Connection reset by peer]
UncleVasya has joined #ocaml
jbrown has joined #ocaml
travisbrady has quit [Quit: travisbrady]
zpe has joined #ocaml
ontologiae_ has joined #ocaml
zpe has quit [Ping timeout: 245 seconds]
pootler has joined #ocaml
pootler_ has joined #ocaml
osnr has joined #ocaml
osnr has quit [Changing host]
osnr has joined #ocaml
chrisdotcode has joined #ocaml
eikke has joined #ocaml
osnr has quit [Ping timeout: 264 seconds]
skchrko has quit [Quit: Leaving]
Kakadu has joined #ocaml
ontologiae_ has quit [Ping timeout: 256 seconds]
Drup has joined #ocaml
zpe has joined #ocaml
yacks has joined #ocaml
<eikke>
with ocp-build, is the '.root' file supposed to be shipped with an application?
<eikke>
(sources)
<eikke>
I assume not since it contains local absolute paths
zpe has quit [Ping timeout: 268 seconds]
osnr has joined #ocaml
osnr has quit [Changing host]
osnr has joined #ocaml
Uvs has joined #ocaml
UncleVasya has quit [Read error: Connection reset by peer]
osnr has quit [Ping timeout: 268 seconds]
mlh has quit [Read error: Connection reset by peer]
mlh has joined #ocaml
dezzy_ has joined #ocaml
skchrko has joined #ocaml
SuperNoeMan_ has joined #ocaml
pippijn_ has joined #ocaml
ohama has quit [Disconnected by services]
cross_ has joined #ocaml
olasd_ has joined #ocaml
ohama has joined #ocaml
MarcWebe1 has joined #ocaml
olasd has quit [Disconnected by services]
domsj has joined #ocaml
olasd_ is now known as olasd
jave_ has joined #ocaml
SuperNoeMan has quit [Ping timeout: 248 seconds]
SuperNoeMan_ is now known as SuperNoeMan
zpe has joined #ocaml
dezzy has quit [Ping timeout: 248 seconds]
jdoles has quit [Ping timeout: 248 seconds]
emmanuelux has joined #ocaml
metasyntax` has joined #ocaml
pippijn has quit [Ping timeout: 248 seconds]
dezzy_ is now known as dezzy
dezzy has quit [Changing host]
dezzy has joined #ocaml
metasyntax has quit [Ping timeout: 248 seconds]
cross has quit [Ping timeout: 248 seconds]
jave has quit [Ping timeout: 248 seconds]
MarcWeber has quit [Ping timeout: 248 seconds]
nicoo has quit [Ping timeout: 248 seconds]
nicoo has joined #ocaml
ollehar has quit [Ping timeout: 240 seconds]
jdoles has joined #ocaml
bholst has joined #ocaml
yroeht has quit [Ping timeout: 276 seconds]
bholst_ has quit [Read error: Connection reset by peer]
domsj has quit [Quit: ERC Version 5.3 (IRC client for Emacs)]
yroeht has joined #ocaml
jan has joined #ocaml
jan is now known as Guest96750
Guest96750 is now known as domsj
wagle_ has joined #ocaml
wagle has quit [Ping timeout: 276 seconds]
zpe has quit [Ping timeout: 252 seconds]
pippijn_ is now known as pippijn
asmanur has joined #ocaml
jave_ has quit [Ping timeout: 276 seconds]
asmanur_ has quit [Ping timeout: 276 seconds]
ulfdoz_ has joined #ocaml
maxibolt has joined #ocaml
mcclurmc has joined #ocaml
mfp_ has joined #ocaml
TaXules_ has joined #ocaml
Nahra_ has joined #ocaml
jave has joined #ocaml
ulfdoz has quit [Ping timeout: 276 seconds]
ulfdoz_ is now known as ulfdoz
thizanne has quit [Ping timeout: 276 seconds]
mfp has quit [Ping timeout: 276 seconds]
TaXules has quit [Remote host closed the connection]
Nahra has quit [Remote host closed the connection]
toolslive has joined #ocaml
<toolslive>
does Core async play nice with OUnit, or does Core have a testing framework that plays nice with async ?
<orbitz>
toolslive: I don't belive it does play well
<orbitz>
I've written tests my hand but I've only done pretty simple things
<orbitz>
hopefully you only need to test a thing layer that is Async and the rest is normal code
osnr has joined #ocaml
osnr has quit [Changing host]
osnr has joined #ocaml
maxibolt is now known as thizanne
<toolslive>
well we have problems with Lwt & OUnit tests. basically you have to start a Lwt_main.run in each test, and then threads run wild and tests hinder each other...
<orbitz>
toolslive: Async is even worse, there is no exit out of the schedular without the entire process ending (AFAIK)
<toolslive>
so how do they test their code?
<orbitz>
No idea
<orbitz>
Perhaps Async has some unit tests in it?
<toolslive>
for some things I tried to functorize Lwt out of it (ie provide a identity monad iso lwt) which works fine for small things, but cannot be generalized.
<toolslive>
then I tried to force async into the same signatures, but failed miserably.
<orbitz>
toolslive: Probably worth asking on ocaml-core
<toolslive>
ow that's a different channel?
<orbitz>
Somebody should really make a standalone library that wraps up Lwt and Async
<orbitz>
toolslive: no, a mailing list
<toolslive>
k.
<Drup>
toolslive: I may be mistaken, but jpdeplaix tried something similar.
<toolslive>
well, there is also oleg's shift-reset lib.
<toolslive>
which can be used to provide the similar concurrency control.
<toolslive>
(clueless about performance though)
zpe has joined #ocaml
osnr has quit [Ping timeout: 268 seconds]
<eikke>
there are quite some tests in the core & async repos
UncleVasya_ has joined #ocaml
<toolslive>
eikke: and how are they strung together?
<eikke>
I'm not sure :P they confused me
<eikke>
modules export a 'tests' value (list of something), but dunno where those are used/executed
Uvs has quit [Read error: Connection reset by peer]
<toolslive>
well, their version number looks impressive ;)
<eikke>
anyone ever built an app using 'core' with ocp-build?