mbishop has quit [Read error: 110 (Connection timed out)]
pango_ has joined #ocaml
mbishop has joined #ocaml
travis|away is now known as travisbemann
sporkmonger has joined #ocaml
sporkmonger has quit []
seafood has joined #ocaml
mgodshall has joined #ocaml
Ched- has quit [Read error: 110 (Connection timed out)]
Ched- has joined #ocaml
seafood has quit [Read error: 110 (Connection timed out)]
coucou747 has quit ["bye ca veut dire tchao en anglais"]
sporkmonger has joined #ocaml
mgodshall has quit ["leaving"]
jeddhaberstro has quit []
Mr_Awesome has quit [Read error: 110 (Connection timed out)]
guillem_ has quit [Remote closed the connection]
seafood has joined #ocaml
seafood has quit [Client Quit]
jeddhaberstro has joined #ocaml
Axioplase has joined #ocaml
seafood has joined #ocaml
seafood has quit [Client Quit]
maattd has quit [Remote closed the connection]
coucou747 has joined #ocaml
Mr_Awesome has joined #ocaml
seafood has joined #ocaml
Mr_Awesome has quit [Client Quit]
seafood has quit [Client Quit]
jeddhaberstro has quit []
seafood has joined #ocaml
seafood has quit [Client Quit]
Axioplase has quit ["leaving"]
jlouis has quit [Remote closed the connection]
Snark has joined #ocaml
seafood has joined #ocaml
jeddhaberstro has joined #ocaml
Kopophex has quit ["Leaving"]
jeddhaberstro has quit []
yziquel has joined #ocaml
yziquel has left #ocaml []
seafood has quit []
filp has joined #ocaml
bluestorm has joined #ocaml
<mrvn>
Is there some way I can say the equivalent of "int foo(int, int);" to get around a circular dependencie?
<mrvn>
For a Foo.foo : Foo.t -> int -> Foo.t function used in Bar that itself uses Bar too.
<mrvn>
I would hate having to put them in one huge file.
Yoric[DT] has joined #ocaml
<flux>
if you have two functions that depend on each other, you will either need to put them into the same file, or pass the other function to the other
itouch has joined #ocaml
<mrvn>
Like Bat.bar : Bar.t -> ('a -> int -> 'a) -> int -> Bar.t and pass it Foo.foo? Complicated here.
<flux>
well, you can then have a third function that has the plumbing done for you ;)
<mrvn>
Actualy I think I would have to pass a tuple (Foo.foo, Bar.bar) as they call each other and I think that the type system doesn't like.
<mrvn>
without rectypes that is
<flux>
hm, really?
<flux>
one approach (which doesn't work for big projects) is using OO, and putting the interfaces into one file, while the implementations can reside in multiple files
<flux>
well, I suppose you could use it just for those two functions - or objects - also
<mrvn>
You mean define 2 base classes FooBase and BarBase and then have the implementations Foo and Bar call the base clases?
<flux>
hmm, not really
<mrvn>
Then I don't see what you mean by "reside in multiple files"
<bluestorm>
what's the problem with the (Bar.t -> ('a -> int -> 'a) -> int -> Bar.t) solution ? are your functions deep down in their modules ?
<flux>
module M = struct class type a = object method foo : b -> int end and b = object method bar : a -> int end end
<bluestorm>
(there is a similar trick using, well, a module-global reference)
<mrvn>
flux: then it is one file.
<flux>
right, I forgot about references, mutable :)
<flux>
mrvn, yes, the interface definition
<mrvn>
bluestorm: In bar.ml: let foo = ref (fun x -> _ -> x) and then in foo.ml reset that to Foo.foo?
<bluestorm>
yes
<flux>
mrvn, but the actual implementation could reside in multiple files
<coucou747>
bluestorm> hi
<mrvn>
flux: Do I need classes for the module thing?
<mrvn>
flux: seems like that should work for normal functions too or not?
<flux>
mrvn, it's just a variation of the "pass the function"-thingy
<flux>
but, refences to the function should be a reasonable solution for you, no? the function types would be simple again.
<mrvn>
bluestorm: What I am afraid of is this:
<mrvn>
# let rec foo fn = function 0 -> 1 | x -> fn fn (x - 1);;
<mrvn>
This expression has type 'a -> 'b -> 'c but is here used with type 'a
<mrvn>
With -rectypes that gives: val foo : ('a -> int -> int as 'a) -> int -> int = <fun>
<bluestorm>
beware
<bluestorm>
sometimes rectypes allows you to type things
<bluestorm>
but they don't actually do what you want
<mrvn>
flux: yeah, if I can pass Foo.foo as argument then a ref would work too.
<flux>
hmm.. can one use the ref-trick with polymorphic functions?
<bluestorm>
flux: if you define the reference correctly, i suppose you can
<flux>
you might need to use a record with a polymorphic field?
<mrvn>
This expression has type int but is here used with type float
<bluestorm>
well, there are not polymorphic
<bluestorm>
-re+y
<flux>
record with polymorphic field: type t = { f : 'a.'a -> 'a }
<mrvn>
# let x = { f = fun x ->x + 1; };;
<mrvn>
This field value has type int -> int which is less general than 'a. 'a -> 'a
<mrvn>
Then you can only assign it polymorphic functions.
<flux>
right, didn't think of that :)
<flux>
however
<flux>
that's not what I originally meant
<bluestorm>
but hey
<flux>
I meant how to express a function such as identity
<bluestorm>
what would you want to pass non-polymorphic functions of different types ?
<flux>
obviously what you're suggesting cannot be typed without a more advanced type system
<bluestorm>
err, s/what/why/
<mrvn>
I think it would at least need a let fn = ref None
<bluestorm>
ref None won't work
<flux>
those instances of functions are not polymorphic
<bluestorm>
"cannot be generalized" blah blah
<flux>
ref (fun _ -> failwith "boo!")
<flux>
I meant function such as val sort : ('a -> 'a -> int) -> 'a list -> 'a list
<flux>
let fn = ref List.sort leads into '_a -types
<flux>
so you need to use a record
<flux>
(or object)
rwmjones_ has joined #ocaml
<mrvn>
flux: But if I create a "ref sort" then I can only assign it other functions with polymorphic type ('a -> 'a -> int) -> 'a list -> 'a list. Not one that only takes a Foo.t
<mrvn>
Same with a record.
<flux>
mrvn, so your problem is not the functions but the types of values they take?
<mrvn>
flux: for a reference yes
<flux>
mrvn, you wouldn't need to assign twice to the reference anyway
<mrvn>
flux: I have to assign something initially and then reassign in Foo.
<mrvn>
Unless I could say "extern Foo.t (*foo)(Foo.t);"
<flux>
mrvn, and you did it successfully above, didn't you?
<flux>
first you initialized the value, then you redefined it
<mrvn>
flux: no. fails because the types differ.
<flux>
but you can't redefine it _twice_
<Yoric[DT]>
hi
<flux>
# let fn = ref (fun _ _ -> failwith "not a sorter");;
<Smerdyakov>
I'm not sure "jokes" from gnu.org are _ever_ appropriate. ;)
<Yoric[DT]>
At the moment, my problem is essentially that with unlimited backtracking come useless error reports.
<Yoric[DT]>
i.e. with enough backtracking, every error comes from line 1, character 1.
<mrvn>
You should insert error rules in the grammar and backtrack till you hit one.
<mrvn>
And then place error rules at strategic positions, like in ( expr ) saying it is missing the closing )
<Yoric[DT]>
I'm not sure.
* Yoric[DT]
is pondering where to place error rules.
dabd has joined #ocaml
<mrvn>
( <error> ) is a good place. Make it stop backtracking when it finds matching parens/braces/brackets
<mrvn>
if you have that
<Yoric[DT]>
I don't quite understand what you mean.
<Yoric[DT]>
Let's consider my current test.
<Yoric[DT]>
A correct program is a possibly empty list of sentences.
<mrvn>
Yoric[DT]: When you hit an error you report it and eat everything up to the matching closing paren. Then you parse normal again and report further errors.
<Yoric[DT]>
Completely different approach.
<Yoric[DT]>
Plus I'm not specially interested in being able to report several errors at once.
<mrvn>
If you have sentences the end of sentence token (if existing) is also a good place to catch errors and return to normal mode.
<Yoric[DT]>
In my case, a correct program is a possibly empty list of sentences.
<Yoric[DT]>
(and no, there are no end-of-sentence tokens)
<Yoric[DT]>
(they are more like lambda-expressions)
<mrvn>
maybe you should give some examples of what the input looks like
<Yoric[DT]>
Now, if one sentence is incorrect, I guess I should report at that point.
<Yoric[DT]>
However, at the moment, my parser backtracks out of the sentence, attempting to find something else to do.
<Yoric[DT]>
Since there's nothing else to do, it backtracks out of the "list of sentences", attempting to find something else to do.
<Yoric[DT]>
So, essentially, the program backtracks to the first character.
<mrvn>
"raise (Parse_Error line_number)"
<Yoric[DT]>
There, it reports that it was expecting something different.
<Yoric[DT]>
Now, why would I do that?
<Yoric[DT]>
I mean, I guess I could assume that any error inside a sentence is necessarily a fatal error.
seafood has quit [Read error: 104 (Connection reset by peer)]
<Yoric[DT]>
But that's not very satisfying.
seafood has joined #ocaml
* Yoric[DT]
guesses it's essentially the same thing as adding cuts in Prolog.
<flux>
hm, can pa_do be used for "monadifying" code?
bluestorm has joined #ocaml
ttamttam has quit [Remote closed the connection]
<Smerdyakov>
flux, what do you mean?
<mrvn>
It is too bad you can do all monads in ocaml.
<mrvn>
can't
<mattam>
Smerdyakov: I guess he means lifting a pure function in an arbitrary monad. Which is maybe pointless (?) by eta-rules of every monad... I wonder.
<Smerdyakov>
mrvn, what do you mean?
<mrvn>
Smerdyakov: you can't do proper continuation monads.
<Smerdyakov>
mrvn, what makes a continuation monad proper?
<mrvn>
Smerdyakov: being able to call it twice or returning it from a function
<Smerdyakov>
It will certainly work fine if you follow a discipline that the type system can't enforce.
<mrvn>
if you return it from a function the stack gets unwinded and then you loose local variables.
<Smerdyakov>
No. With an explicit continuation monad, all relevant data dependencies are reified in closures.
<bluestorm>
(what's the problem with OCaml continuation monad ?)
<mrvn>
Smerdyakov: and how do you implement that in ocaml?
<Smerdyakov>
mrvn, the same way as in Haskell.
<mrvn>
Smerdyakov: that means fixing up the compiler
<Smerdyakov>
type 'a cm = ('a -> bool) -> bool
<Smerdyakov>
let return x k = k x
<Smerdyakov>
let bind m1 m2 k = m1 (fun x -> m2 x k)
<Smerdyakov>
bluestorm, tail recursion only matters with poor compilers like ocamlopt.
<bluestorm>
(i like the tail-recursive fold-right using continuations; you may be arguing that we don't need "first-class" continuations to do that)
<Smerdyakov>
bluestorm, with either MLton or SML/NJ, there are only small constant factor performance degradations, at worst, if you don't write tail recursively.
<bluestorm>
how so ? do they use tail-recursification in the background ?
<bluestorm>
(using reified continuations ?)
<Smerdyakov>
No. The stacks are heap-allocated.
<bluestorm>
hm
<bluestorm>
so you lift the stack limit from the stack OS limit (wich is low) to the heap limit, wich is high ?
<Smerdyakov>
I always have trouble remembering the terminology. There's one word for recursive definitions with self-calls only in "tail positions," and there's another for the same where you keep a constant size bound on an accumulating argument.
<Smerdyakov>
The latter is always going to be important without very involved automatic optimization. The former only matters when "the stack" is treated as a scarce resource.
<Smerdyakov>
So, for instance, forcing yourself to write list reverse tail-recursively is an example of a waste of time done only to satisfy the former criterion.
<mrvn>
I think stacking the recursion into arguments instead of the stack is cheating and not tail recursion.
<mrvn>
Smerdyakov: lt reverse = let rec loop acc = function [] -> acc | x::xs -> reverse (x::acc) xs in loop []
<mrvn>
Smerdyakov: How else would you write that?
<mrvn>
s/reverse/loop/ for the last one.
<Smerdyakov>
Yes, I picked a bad example. I don't know how to do it substantially differently without tail recursion and without increasing the asymptotic running time/.
<bluestorm>
perhaps you were considering list length ?
<Smerdyakov>
An example like implementing [foldr] by reversing the input list first is much better.
<mrvn>
bluestorm: concerning curried-intuitions. I don't think that is quite a real continuation monad. As I understand it you have to change your code flow to CPS style. You need to call the monad with a function that is all the code after the monad.
<bluestorm>
hm
<mrvn>
bluestorm: so you end up writing all your code in CPS style with a little suggar added.
<bluestorm>
well, is that not what a CPS monad is about ?
<mrvn>
bluestorm: Imagine this: let cc = Continuation.create () in ....; Continuation.callcc cc
<Smerdyakov>
mrvn, without explicit "return" and "bind" operators, you have no monad, by definition.
pango_ has quit [Remote closed the connection]
pango_ has joined #ocaml
hkBst has joined #ocaml
Anarchos has joined #ocaml
<flux>
hmm, I notice that ocaml toplevel does little to help developing cps-style programs..
<flux>
any tips/tricks on that?
asmanur has quit ["leaving"]
<flux>
ideally there could be something like: some_fun (fun arg -> <>) and next toplevel prompt would be at the point of <>, with arg bind as expected
<flux>
any syntax extension ideas on that?-)
asmanur has joined #ocaml
<bluestorm>
hm
<bluestorm>
doesn't that require deeper mechanisms that a syntax extension ?
<flux>
I suppose it does
<bluestorm>
you could write your CPS program at the metaOCaml level
<bluestorm>
metaocaml has nice printing capabilities
travisbemann is now known as travis|away
<bluestorm>
(you'd have a standard-ocaml 0-stage CPS monad building metavalues)
<flux>
what I actually have is more like run (foo >>= bar >>= exit), but it would be nice to stop and interactively meddle with stuff in the middle
<Smerdyakov>
I've written _lots_ of CPS OCaml code, and I've never once wanted such a mechanism.
<flux>
do you think toplevel in itself is useful?
<Smerdyakov>
Yes, but I only use it for testing code, not writing anything remotely complicated.
marmotine has joined #ocaml
netx has quit [Read error: 110 (Connection timed out)]
<flux>
that's exactly what I'm doing
<flux>
I have a library for interfacing with a device in the network, which uses threads
<flux>
it's quite easy to use from toplevel - ping, retrieve event lists, etc - those all are single commands
<flux>
but if I were to the system into a threadless monad, I think I would no longer be able to use toplevel efficiently
<flux>
well, I suppose I could write a look that fetches messages from a queue which I could send messages into from the toplevel
<Smerdyakov>
I have my doubts. You would probably just need to write some new combinators just for testing.
<Eridius>
I've never really understood... what *is* a Monad?
<Smerdyakov>
Eridius, "monads" are an algebraic structure like groups, rings, and fields.
<flux>
eridius, that's an excellent question
* Eridius
chuckles
<flux>
I believe it is a source of thoudands of tutorials
<Smerdyakov>
Eridius, just like a group must have a binary operator, so must a monad -- it's not open to debate, and this is why mrvn's discussion about an "implicit CPS monad" was ill-formed.
<Smerdyakov>
Eridius, the abstraction of a group captures who-knows-what; the abstraction of a monad captures notions of sequential computation.
netx has joined #ocaml
<Eridius>
ok...
Anarchos has quit ["Vision[0.8.5-0418]: i've been blurred!"]
<flux>
smerdyakov, I'm not sure how a combinator library helps me get in and out of the monad for top-level testing.. when I get out of the monad, all communications dies, so I can't let that happen.
<Smerdyakov>
Eridius, starting from this knowledge, which shows that monads have nothing to do with imperativity by nature, the Wikipedia article should be enough to explain the details.
<Smerdyakov>
flux, you have to write whole transactions as single "commands."
<Eridius>
I'm pretty sure I've read the wikipedia Monad article before, but I'll try again
<Eridius>
flux: I think I've already read that article, but I also think that was probably my first article on Monads. I should re-read it having been exposed to Monads a bit more now
<bluestorm>
Eridius: read different things while you don't get it
<Smerdyakov>
Eridius, "monads" is not properly capitalized, unless you're referring to the Haskell type class, in which some kind of bracketing of literal quoted syntax would be appropriate.
<Smerdyakov>
s/in which/in which case
<Eridius>
ok
<bluestorm>
it seems that repetition with slight variants and exposition to different point of views helps more that The Ultimate Monad Tutorial
<hcarty>
gildor: I've been following the pa-do work for a while now - it has been interesting watching their progress and I've already made a few bug reports and feature requests. Thank you for the links though.
<Smerdyakov>
Anyone with any mathematical sophistication should only need to read the definition of a monad, in the same vein as definitions of standard algebraic structure, and read a few examples of monad definitions.
<bluestorm>
Smerdyakov: function composition alone can express sequencing
<Eridius>
Smerdyakov: my mathematical learnings have been sporadic since high school
<bluestorm>
i think you need to take into account the idea of "computation with implicit stuff going on"
<Eridius>
what I learned from Haskell was that the Monad encapsulated sequential programming along with this weird idea about handling implicit extra data values
<flux>
the closest to monads for me has been by first writing a CPS-based library for message passing
<flux>
and then finding out that plumbing stuff is inconvenient
<flux>
and then applying the monad-concept to it
<Smerdyakov>
bluestorm, I said "sequential computation," not "sequencing." Besides, order doesn't matter in total type theory, but monads as notions of computation are still interesting there.
<bluestorm>
agreed
<bluestorm>
what do you mean by "order doesn't matter" ?
<Smerdyakov>
When people with some passing familiarity with Haskell are confused about "what monads are," the problem is always this:
<Smerdyakov>
Monads provide no new capabilities.
<Smerdyakov>
They are a tool for noticing similarities in different solutions to the same general suite of problems.
<Smerdyakov>
bluestorm, all reduction orders yield equivalent results.
<Eridius>
I thought monads were important when you had side effects
<bluestorm>
that's Smerdyakov point i guess : they are not specifically related to side effects
<Smerdyakov>
No. The ad-hoc solution that Haskell has chosen for injecting side effects happens to be an instance of "the monad design pattern."
<Eridius>
ok
<Smerdyakov>
Even better, this fact can be reified with membership in a type class.
<flux>
a unique world-variable is important when you have side effects, and monads give a tool for threading that variable around ;)
<Eridius>
"reified"?
<Smerdyakov>
"Made into a thing"
<Eridius>
ok
<Smerdyakov>
flux, no. "Monad" is a class of solutions that includes the solution you mention.
<Smerdyakov>
flux, the monad ADT alone does not permit threading of state. You have to add extra operations.
<flux>
smerdyakov, by "give a tool" I just meant that, not that they are (only) the tool
<flux>
I'm not sure how I would've said it less ambigiously
<Smerdyakov>
flux, no. Monads are not a tool for solving that problem.
<flux>
hm
<bluestorm>
i was going to pointlessly note that the monad ADT can thread state, only it can't change/access it
<Eridius>
what's "ADT"?
<bluestorm>
Abstract Data Type
<bluestorm>
hm
<Eridius>
ok
<bluestorm>
or Algebraic
<bluestorm>
depends on the context
<bluestorm>
he certainly meant Abstract
<Smerdyakov>
I meant the "Abstract" version.
<Smerdyakov>
flux, regardless of objective correctness, the way you're putting things is misleading.
<Smerdyakov>
flux, it's like saying that language is a good tool for conflict resolution.
<Smerdyakov>
flux, a naive listener might conclude that shouting insults will help him resolve his conflicts.
seafood has quit []
<Smerdyakov>
And, in this case, I guess a better analogy would be a naive listener concluding that shouting insults isn't language, because it isn't effective for conflict resolution.
dabd has quit ["Ex-Chat"]
<Eridius>
I really wish my school taught OCaml or Haskell
<Eridius>
the absolute closest it came was a 4000-level course called Programming Languages, which spent one week looking at Haskell purely as an exercise in lazy evaluation
<Eridius>
the rest of the class was devoted to using Scheme to implement a new language
<Smerdyakov>
Programming language classes are generally crap. I can only see a reason to agree with you if you're going to have to take crappy classes anyway and want to minimize their crappyness.
<bluestorm>
Eridius: what does "4000-level" mean ?
<Eridius>
bluestorm: I thought most colleges had numbering schemes like that? the 1000-level classes are introductory classes, then 2000-level classes are a bit harder, then 3000-level, then 4000-level. It refers to the number used to identify the class
<Eridius>
like CS4051
<bluestorm>
(and one week of lazy-eval using Haskell with the rest of Scheme implementing a toy language sounds like pretty interesting and a reasonable choice for a programming class)
<Smerdyakov>
At least in America, I think that numbering scheme is very rare.
<Eridius>
bluestorm: it was actually the most interesting CS course offered, but I just wish it went farther
<Smerdyakov>
And most people here aren't American....
<Eridius>
huh
* Eridius
is American
<Camarade_Tux>
Eridius, I think that about a third of people here are french ;)
<Eridius>
huh
bluestorm has quit [Remote closed the connection]
leyyer_su has joined #ocaml
jynxzero has quit ["BRB"]
jynxzero has joined #ocaml
<mfp>
aha! funny bug
<mfp>
let n = dosomething foo in printf "n is %d\n" n; for i = 1 to n - 1 do printf "%d\n" i done; ...
<mfp>
prints "n is 7", then 1, 2, .... 100000, ...... (endless loop)
pango_ has quit [Remote closed the connection]
<mfp>
with external : dosomething : .... -> int
<mfp>
this gives it away, but I sure had a wtf moment as I reviewed the .s, looking for some compiler bug
pango_ has joined #ocaml
leyyer_su has quit [Remote closed the connection]
netx has quit [Connection timed out]
maattd has joined #ocaml
Axioplase_ is now known as Axioplase
itouch has quit [Read error: 113 (No route to host)]
maattd has left #ocaml []
maattd has joined #ocaml
<rwmjones_>
damn, googlecode is down for "brief" network maintenance ...
<Smerdyakov>
It's "reputable" but generally ignored outside its narrow constituency.
<Smerdyakov>
I would guess that everyone presenting a paper at IFL would rather be presenting it at ICFP.
<Smerdyakov>
(Or almost everyone)
<Smerdyakov>
It's even more European than ICFP.
<Smerdyakov>
Which generally means laxer standards of real-world relevance. ;)
<rwmjones>
Smerdyakov, cheers .. good to know. It's just that the conference is down the road from me :-)
<rwmjones>
anyhow this is functional programming, it's not supposed to deal with the messy 'real world' :-) :-)
Mr_Awesome has joined #ocaml
* Myoma
would go to IFL if it was near
maattd has quit [Read error: 110 (Connection timed out)]
maattd has joined #ocaml
Myoma has quit [Read error: 104 (Connection reset by peer)]
Myoma has joined #ocaml
itouch has quit [Read error: 113 (No route to host)]
asmanur has quit [Remote closed the connection]
Myoma has quit [Read error: 113 (No route to host)]
Myoma has joined #ocaml
bluestorm has quit [Remote closed the connection]
tomh-_ has joined #ocaml
tomh-_ is now known as tomh
maattd has quit [Remote closed the connection]
rhar has joined #ocaml
bzzbzz_ has joined #ocaml
Snark_ has joined #ocaml
Snark has quit [zelazny.freenode.net irc.freenode.net]
sporkmonger has quit [zelazny.freenode.net irc.freenode.net]
bzzbzz has quit [zelazny.freenode.net irc.freenode.net]
sporkmonger has joined #ocaml
wlmttobks has joined #ocaml
wlmttobks has quit [K-lined]
Snark_ has quit ["Ex-Chat"]
<hcarty>
The docs recommend against using ( $ ) as an OCaml operator because it is used by camlp4. Could anyone here comment on the applicability of this warning outside of a camlp4 extension?
<rwmjones>
hcarty, yes, very important to avoid $ and also << and >>
<rwmjones>
since they'll prevent your code from being _parsed_ by camlp4
* Yoric[DT]
keeps having difficulties with error reporting in a parser combinator.
<hcarty>
rwmjones: Thank you
rwmjones has quit [Remote closed the connection]
<Myoma>
amusing
<Myoma>
A novice came to Jacques Garrigue and spoke nervously: "I don't get rank-2 polymorphism. What is it good for? When to use it? How can I understand it?". Jacques asked: "Do you want an answer to each question, or the answer to all your questions?." The novice was enlightened.
<Eridius>
ah, an eigenclass reader
jderque has left #ocaml []
Associat0r has quit []
yziquel has joined #ocaml
hkBst has quit [Read error: 104 (Connection reset by peer)]
asmanur has joined #ocaml
mgodshall has joined #ocaml
Toonto_del_alma has left #ocaml []
<yziquel>
Small question about netclient: what's the function to convert an & to a & in an url?
<flux>
it might not have any. isn't & a html-thing anyway?
<yziquel>
Should be, but it seems that Http_client.Convenience.http_get complains.
<flux>
complains what?
<yziquel>
well, putting an & doesn't retrieve the correct web page, and with a & instead, it does.
<Yoric[DT]>
'night everyone
Yoric[DT] has quit ["Ex-Chat"]
<flux>
yziquel, where are you getting this & and why would you put it to an url?
<flux>
wouldn't & be escaped as %26 in an url?
<flux>
uh, I'm getting my articles quite wrong tonight