keen___________3 has quit [Read error: Connection reset by peer]
keen___________3 has joined #ocaml
darryn has joined #ocaml
<darryn>
How do i determine when a function/arg/code is finished when there is no ";" or "()" like in c++ or lisp?
<Drup>
struktured: a good amount of laptop only have an intel "video" card to decode video and that's all
<struktured>
that's true, but alot have amd / nvidia chipsets too. the heavier to carry ones usually :)
<struktured>
darryn: by structural induction ? seriously though, you can follow the code from start to finish and verify the ast is a valid expression/type/etc.
<dmbaturin>
darryn: When the next token is "let", "module", or "open" ("or "class"/"object"), previous code part is finished.
<darryn>
ah, thank you.
<struktured>
darryn: in practice, you can also just look at the module signatures to see how many args they take
<struktured>
darryn: or better, use merline and TypeOf
<struktured>
*merlin
<darryn>
First functional programming language, a lot to take in.
<struktured>
darryn: there are semicolons too (basically means the last thing must return the unit type and the next thing is new expression), as well as begin/end constructs
<darryn>
Are those needed or just for personal use?
<dmbaturin>
The semicolon is statement separator, not terminator. let () = print "foo"; would be an error.
<darryn>
hm
zpe has joined #ocaml
<dmbaturin>
Well, not error per se, but it will capture whatever comes next. In other words, "foo x; bar y" is pretty much equivalent to let () = foo x in bar y
<darryn>
so another let would seperate them?
<struktured>
dmbaturin: funny I was about to say that, tried it in utop, the first assumes foo is 'a -> 'b, not 'a -> unit, but the essence of your point is still valid
<darryn>
but let foo = let bar bar = x;; is one expression
<darryn>
is this because let is the first expression of the var foo?
<struktured>
your expression doesn't seem syntaicallyl valid. you're missing an "in" or two
zpe has quit [Ping timeout: 256 seconds]
<dmbaturin>
The point I wanted to make: don't end sequences of expressions with semicolons. :)
<struktured>
which is liberating, to me
<darryn>
so in order to have a (let foo = let bar = x) we would have to have another expression to finish? Like (let foo = let bar = x in x + 1 ;;)?
<dmbaturin>
Also, ";;" is never necessary in source files, and is usually considered a bad style (in the REPL it's necessary to make it accept and compile the chunk of code you entered).
BitPuffin|osx has quit [Remote host closed the connection]
<dmbaturin>
The general form is <binding> ::= let <pattern> = <expression> in <expression|binding>
<struktured>
darryn: this would compile: "let foo x = let bar y = y+1 in bar x"
<dmbaturin>
"let foo = 9 in foo + 1", "let f x y = x * y", "let f x y = let g x = x + 1 in y (g x)" would be valid.
idegen has quit [Quit: Leaving.]
ygrek has joined #ocaml
<darryn>
struktured: I don't know why, but I am having trouble wrapping my brain around that code. When I pass foo 5, i don't know what happens...
<darryn>
sad, I know
<dmbaturin>
Pass to where?
<darryn>
So let foo x = let bar y = y+1 in bar x
<darryn>
when I do: foo 5
<dmbaturin>
"(let ([f (lambda (x y) (* x y))]) (f 2 3))" => "let f x y = x * y in f 2 3"
<def`>
struktured: and you said that it's possible to have gpu's in the cloud?
amnn has quit [Quit: My MacBook Pro has gone to sleep. ZZZzzz…]
<struktured>
darryn: it's ok, it's very pointless code. it binds a function called foo to a var x, inside the function we bind another function called bar with a var y, we then evaluate bar with x inside of the function definition, returning x+1 effectively.
<dmbaturin>
...except top-level let (not inside let ... in) can also work like (define name expr)
<dmbaturin>
(Can't write common lisp off the top of my mind, I prefer the uncommon one :)
<darryn>
Okay, I am understanding it now, don't know how, but I am haha.
leafac has joined #ocaml
badon has quit [Disconnected by services]
badon_ has joined #ocaml
badon_ is now known as badon
<darryn>
why does let foo x = let bar y = y+1 in bar x*3;; foo 5;; return 18? we have 5*3=15, then 15+1=16. Unless my arithmetic is terrible, what's going on?
<struktured>
darryn: associativity is tricking you.
<struktured>
Drup: I wonder if that should be done with some of oml's matrix operations.
<struktured>
matrix rebinding get's you very close to a typed matlab in utop
<Drup>
struktured: well yeah, did you looked at the example ?
<struktured>
onthe README.md itself?
<Drup>
writing smt terms become really easy with that, and it's easier to read too
<Drup>
yes
<dmbaturin>
I never buy dead tree editions when a DRM-free digital version is available (not as much to save trees as to not worry about shipping and other problems of physical objects).
<darryn>
"dead tree editions" lmao
<struktured>
Drup: I see "int x", is that how the operators handle different types? through a variant?
<darryn>
Who here works with OCaml for their job?
<Drup>
struktured: it's not through a variant, but yeah
<struktured>
darryn: starting to, I have done about 80% ocaml for past two weeks
<nullcat>
still a student..
<yomimono>
as of recently, my job is ocaml
<struktured>
Drup: got it. cool. that's neat
BitPuffin|osx has joined #ocaml
<darryn>
It seems like there is a demand for good Ocaml developers.
<struktured>
darryn: in NYC area you can probably get a job as one, if you really want
<tokenrove>
speaking of which, if anyone is looking for freelance ocaml work, i recently had to turn some down for various reasons and could recommend you to the client.
<nullcat>
yomimono: first time see you here
<yomimono>
:) I lurk here sometimes
<darryn>
Well, I want to move out of this state/country, so if I found a job in France, I wouldn't complain.
<darryn>
Not that I am even close to being good enough
<yomimono>
i'm not very good and yet somehow money is arriving
<yomimono>
there is hope :)
<darryn>
I haven't had a job in my study field yet, just retail and factory work. Hopefully graduating will change that.
<yomimono>
it won't hurt, that's for sure. prospects improved for me drastically after finishing my degree
<darryn>
How can I work in my field and continue college?
<dmbaturin>
tokenrove: What's the job about?
<darryn>
brb
<tokenrove>
dmbaturin: it involves audio processing and is a substantial amount of work. that's about all i can say publically. msg me if you are interested.
<dmbaturin>
Ah. Well, I know pretty much noting about audio processing.
tinhead has joined #ocaml
cdidd_ has joined #ocaml
mcc has quit [Quit: This computer has gone to sleep]
c74d has quit [Remote host closed the connection]
cdidd has quit [Ping timeout: 245 seconds]
c74d has joined #ocaml
tinhead has quit [Remote host closed the connection]
badon has quit [Quit: Leaving]
tinhead has joined #ocaml
tinhead has joined #ocaml
yomimono has quit [Quit: Leaving]
leafac has quit [Quit: Leaving.]
leafac has joined #ocaml
tinhead has quit [Remote host closed the connection]
leafac has quit [Client Quit]
rgrinberg has quit [Ping timeout: 245 seconds]
darkf has joined #ocaml
agarwal1975 has quit [Quit: Connection closed for inactivity]
tinhead has joined #ocaml
rgrinberg has joined #ocaml
ethycol has joined #ocaml
zpe has joined #ocaml
zpe has quit [Ping timeout: 272 seconds]
sdothum has quit [Quit: ZNC - 1.6.0 - http://znc.in]
tinhead has quit [Remote host closed the connection]
idegen has joined #ocaml
<dmbaturin>
Why ocamlnet opam package builds without TLS by default? What's the easiest way to change it?
darryn has quit [Read error: Connection reset by peer]
tinhead has joined #ocaml
<hnrgrgr>
dmbaturin: because the package 'conf-gnutls' is only a optional dependency in the ocamlnet package
tinhead has quit [Changing host]
tinhead has joined #ocaml
<hnrgrgr>
"opam install conf-gnutls" should recompile ocamlnet with TLS.
<dmbaturin>
hnrgrgr: Thanks!
tinhead has quit [Remote host closed the connection]
badon has joined #ocaml
darryn has joined #ocaml
idegen has quit [Quit: Leaving.]
tmtwd has quit [Ping timeout: 265 seconds]
zpe has joined #ocaml
ygrek has quit [Ping timeout: 246 seconds]
<darryn>
how can you pm on irc?
<rgrinberg>
darryn: /query <username>
zpe has quit [Ping timeout: 245 seconds]
Algebr has joined #ocaml
<Algebr>
what benefits does ocp-build have over a makefile?
<rgrinberg>
Algebr: it makes you look more like a haxxor
<rgrinberg>
and its microscopically faster
<Algebr>
I'd like to at least read the manual but the link online goes to a 404
<Algebr>
so I guess I will gander at the src.
<rgrinberg>
Algebr: ocp-build is dead, how come you want to use it?
<Algebr>
I didn't know it was dead. I just saw it for the first time and was curious but I guess you just saved me a lot of time.
<Algebr>
what are the current active projects for building?...oasis?
<rgrinberg>
Algebr: they pulled the source from github too so I don't think you'd find it
<Algebr>
while, opam archive
<Algebr>
why*
<rgrinberg>
oasis is the most popular. but there's probably like 5 other choices that are common
<Algebr>
but is oasis the one with the most effort, direction?
<rgrinberg>
people kept making bug reports and contributors, i think it ended up annoying the maintainer. no idea though
gabemc has joined #ocaml
<rgrinberg>
Algebr: hard to say. they're all pretty stagnant
<rgrinberg>
assemblage is the new hope
<rgrinberg>
although it's not usable yet
<Algebr>
I think I'm just going to keep using makefiles and forget about this whole area for a couple years.
<rgrinberg>
Algebr: good idea :) OCamlMakefile causes very little headaches
<dmbaturin>
What's assemblage?
<rgrinberg>
it helps to know the basics with oasis though if you're contributing to other people's code though
MrScout has quit [Read error: Connection reset by peer]
gabemc has quit [Ping timeout: 276 seconds]
MrScout has joined #ocaml
freling has joined #ocaml
ygrek has joined #ocaml
zpe has joined #ocaml
ollehar has joined #ocaml
ggole has joined #ocaml
<jita>
what the syntax differences between f# and ocaml? Is it easy to pick one and later translate the code to another ?
milosn has quit [Quit: Lost terminal]
milosn has joined #ocaml
tmtwd has quit [Ping timeout: 272 seconds]
robink has quit [Ping timeout: 255 seconds]
tinhead has joined #ocaml
dsheets has quit [Ping timeout: 272 seconds]
<apache2>
for one, the modules are different
tinhead has quit [Remote host closed the connection]
<smondet>
jita: AFAIR there is even some code that cross-compiles between both languages but it uses a very restricted subset of both: the CamlPDF library
<tane>
jita, F#'s parsing rules are a little different as white space is a bit more significant. the object system has been valued higher due to the underlying platform. there's no functor system
<jita>
Coming from python background in Unix platform, which should I start learning? Which syntax will be easier for me ? THanks
<tane>
syntax is not that difficult and different
<tane>
if you want to do development for the unix platform i'd recommend ocaml
<tane>
mono is just not as performant and the toolchain for ocaml development is much better
robink_ has joined #ocaml
<tane>
at least on *nix
<tane>
another plus: ocaml has a nice community (i do not have any experience with the F#, so that's more of an absolute than relative statement) :)
<jita>
right thanks. What would be best way to start ocaml learning ?
<tane>
you already have experience with python, any more functional oriented language as well?
<rgrinberg>
Drup: you should recruit harrop for the assemblage team
<tane>
jita, https://realworldocaml.org/v1/en/html/index.html this is a good book, its using a 3rd party standard library overlay, but it should teach the basics nevertheless. as it's free i'd at least keep it bookmarkd. there are lighter tutorials on ocaml.org
<dmbaturin>
jita: Also, the syntax is (mostly) simple and straightforward. It's semantics behind that syntax that can be confusing.
<jita>
dmbaturin: is it simpler than haskell ?
<rgrinberg>
ocaml is simpler than haskell for writing real world programs
<rgrinberg>
that's for sure
<dmbaturin>
I think it is.
jeffmo has quit [Quit: jeffmo]
<dmbaturin>
jita: Even though there are imperative features and object system, it's not what most people would use by default (while in python almost everything is mutable by default and the OO system is the only way to introduce user-defined types).
<jita>
ok
<dmbaturin>
It's not really a social convention to avoid them, in the presence of alternatives (algebraic types and pattern matching and the module system) they are simply not the best way to express ideas.
<jita>
ok thanks for the information
robink_ is now known as robink
seanmcl has quit [Quit: My MacBook Pro has gone to sleep. ZZZzzz…]
tinhead has joined #ocaml
<dmbaturin>
The default encapsulation mechanism is abstract types (there's a type in the module implementation, but module interface doesn't expose its real definition and clients only know it as Mymodule.mytype, so they can pass a value around but can't do anything to it, other than by using functions from the module itself).
zpe has quit [Remote host closed the connection]
tinhead has quit [Remote host closed the connection]
Algebr has joined #ocaml
jwatzman|work has quit [Read error: Connection reset by peer]
seanmcl has joined #ocaml
jwatzman|work has joined #ocaml
MrScout has quit [Read error: Connection reset by peer]
kushal has quit [Ping timeout: 256 seconds]
MrScout has joined #ocaml
kushal has joined #ocaml
postulonce is now known as catapulpe
nullcat has joined #ocaml
tinhead_ has joined #ocaml
cml__ has quit [Ping timeout: 246 seconds]
seanmcl has quit [Quit: My MacBook Pro has gone to sleep. ZZZzzz…]
nullcat has quit [Remote host closed the connection]
nullcat has joined #ocaml
seanmcl has joined #ocaml
kdef has quit [Quit: Leaving]
tinhead_ has quit []
tinhead has joined #ocaml
nullcat has quit [Ping timeout: 246 seconds]
tinhead has quit [Remote host closed the connection]
tinhead has joined #ocaml
tinhead has joined #ocaml
obadz has quit [Ping timeout: 245 seconds]
nullcat_ has joined #ocaml
obadz has joined #ocaml
freling has quit [Quit: Leaving.]
freling has joined #ocaml
nullcat has joined #ocaml
nullcat_ has quit [Read error: Connection reset by peer]
kdef has joined #ocaml
lordkryss has quit [Quit: Connection closed for inactivity]
struk|work has quit [Ping timeout: 246 seconds]
amnn_ has joined #ocaml
amnn has quit [Ping timeout: 265 seconds]
Cyanure has joined #ocaml
nullcat has quit [Ping timeout: 265 seconds]
freling has quit [Quit: Leaving.]
blandflakes has quit [Ping timeout: 256 seconds]
Kakadu has quit [Quit: Page closed]
freling has joined #ocaml
idegen has quit [Quit: Leaving.]
idegen has joined #ocaml
blandflakes has joined #ocaml
rwmjones has quit [Quit: Terminated with extreme prejudice - dircproxy 1.2.0]
tinhead has quit [Remote host closed the connection]
rwmjones has joined #ocaml
freling has quit [Client Quit]
freling has joined #ocaml
jeffmo has joined #ocaml
<jita>
how to enable tab completion in repl in terminal ?
<Drup>
in utop ?
<Drup>
alt down
<jita>
Drup: i am not using utop, should i use it ?
<Drup>
yes
<jita>
right thanks
slash^ has quit [Read error: Connection reset by peer]
tmtwd has joined #ocaml
rgrinberg has quit [Ping timeout: 240 seconds]
thomasga has quit [Quit: Leaving.]
jita_ has joined #ocaml
jita has quit [Ping timeout: 246 seconds]
jgjl has joined #ocaml
thomasga has joined #ocaml
nicoo has quit [Ping timeout: 272 seconds]
mrknife has left #ocaml ["Bye!"]
Submarine has joined #ocaml
Submarine has joined #ocaml
TheLemonMan has joined #ocaml
jgjl has quit [Ping timeout: 255 seconds]
manizzle has joined #ocaml
Kakadu has joined #ocaml
dsheets has joined #ocaml
nicoo has joined #ocaml
tinhead has joined #ocaml
<orbitz>
Hello, I have a foo.ml where is just: include Some_functor.Make(M) and the .mli is the manually expanded version of that. Howver I'm hitting a problem in another module where the type checker doesn't realize that Foo and Some_functor.Make(M) are the same thing. What am I missing?
nicoo has quit [Quit: WeeChat 1.1.1]
<smondet>
orbitz: sounds like one or more `... with type .. = ..` are missing, difficult to tell without the code
<orbitz>
smondet: where would the with type go? The application in foo.ml?
hay207 has quit [Ping timeout: 240 seconds]
<smondet>
orbitz: or the other one, I'm not sure :-/
<orbitz>
hehe
<orbitz>
I think it is acase of that aswell...i'm just not sure where
<orbitz>
The problem being I have Some_functor.Make(M).t and Foo.t and compiler says they are not the same thing
nicoo has joined #ocaml
<Drup>
show the code
<smondet>
orbitz: how are you exporting Foo.t in the mli?
<Drup>
it's impossible to debug like that.
tinhead has quit [Remote host closed the connection]
<orbitz>
Drup: Right now thre is too much code, I was hoping it was an obvious thing
nullcat has joined #ocaml
ygrek has quit [Ping timeout: 256 seconds]
ggole has quit [Read error: Connection reset by peer]
amnn_ has quit [Read error: Connection reset by peer]
rgrinberg has joined #ocaml
amnn has joined #ocaml
tinhead has joined #ocaml
<orbitz>
smondet: hrm, I think you're right that I'm not exposing enough type information
<orbitz>
Will play with it more tomorrow, night!
<Drup>
orbitz: it is probably rather obvious, if you know where to look
_andre has quit [Quit: leaving]
badkins has quit []
<nullcat>
ha that reddit thread..
<Drup>
nullcat: it was not a brilliant idea :D
<nullcat>
well, i tried to ask in a gentle way
<nullcat>
and by no means i'd like to encourage any personal attacks
<nullcat>
maybe i should change my wording a little bit to make it more gentle? =_=
<nullcat>
but yeah, i don't like that guy either...
<Algebr>
why oh why does ocamlnet have a dependency on lablgtk
tinhead has joined #ocaml
<tokenrove>
Algebr: i prefer ocaml, but f# is quite decent compared with other things in the .net ecosystem. i worked for a while with a company with a large c# codebase where f# was a great way to bring in a more elegant language while refactoring. (plus, the units-of-measure support was handy)
<Algebr>
tokenrove: thanks, appreciate the insight
tinhead has quit [Remote host closed the connection]
tinhead has joined #ocaml
<rgrinberg>
i've used f# as well. I have a slight preference towards ocaml language wise but i can't stand the f# ecosystem
<rgrinberg>
i think that they're complimentary though. you can use f# in a lot of places where it's impossible/too hard to use ocaml
<rgrinberg>
cross platform mobile with xamarin, windows, games with monogame, unity, etc.
<rgrinberg>
although obviously flask is more complete and mature
<jita_>
ok
<rgrinberg>
generally, if i'm staring a project i expect to maintain i will always try to pick ocaml
<rgrinberg>
python makes maintenance a nightmare
<jita_>
right
<MercurialAlchemi>
well, it depends on the size of the codebase
kushal has quit [Ping timeout: 272 seconds]
<MercurialAlchemi>
but it's certainly a lot easier to write code which works as expected in OCaml than in Python
<MercurialAlchemi>
on the other hand, the library problem can be harder to work around with, depending on what you're working on
tinhead has joined #ocaml
tinhead has joined #ocaml
leafac has quit [Quit: Leaving.]
<jita_>
ok thanks for the information
<jita_>
which other languages you guys like besides python and ocaml?
<rgrinberg>
f#, haskell, rust :P
<Algebr>
i like swift
Anarchos1 has joined #ocaml
<rgrinberg>
swift is a good language. but i don't want to use proprietary languages
<Denommus>
my biggest issue with F# is that they don't have ML modules, and don't have anything to replace them. So it becomes hard to make code less repetitive
<jita_>
rgrinberg: rust is not a general purpose language right? Would you use it where you would use ocaml/python ?
<Leonidas>
I didn't like swift that much when I tried it
<Denommus>
jita_: Rust is a general purpose language
<rgrinberg>
jita_: rust it too level for most tasks that i do. i really like rust's macros though
<rgrinberg>
s/level/low level/
<Leonidas>
pattern matching wasn't an expression, that scared me off
<Denommus>
jita_: it's just somewhat harder to do most applications on it because it provides safety through a lot of constraints. It's really designed for systems
<Denommus>
Leonidas: ewww
tinhead has quit [Remote host closed the connection]
<Leonidas>
maybe that was fixed or maybe I misunderstood something, don't know. I haven't had any use for it, so I just skipped it
tinhead has joined #ocaml
<Denommus>
it's harder for me to get excited for an application language other than Haskell and OCaml, really
<Denommus>
s/harder/hard/
<MercurialAlchemi>
Rust looks superficially like ML languages but it is really geared toward low-level work
<Denommus>
and I used to be a hardcore Lisper
<MercurialAlchemi>
Idris looks interesting
<Denommus>
MercurialAlchemi: ah, indeed, I forgot about Idris
<Leonidas>
Denommus: Typed Clojure! :-)
<Leonidas>
Edwin Brady of Idris is a hilarious guy
tinhead has quit [Remote host closed the connection]
<Denommus>
Leonidas: isn't Typed Clojure optionally typed? I don't like optional types
<Denommus>
there's Typed Racket, but its type system is too rudimentary to be productive
<Drup>
rgrinberg: unity support for F# will be very welcome too
<Leonidas>
Denommus: I think Typed Clojure is rather similar to Typed Racket
tinhead has joined #ocaml
<Denommus>
I just found out about (@@). I feel stupid
<Leonidas>
@@ is great, I use it all the time
<Leonidas>
and the remaining time I use |>
<rgrinberg>
i kind of wish it was never introduced :/ everyone is overusing it
<Leonidas>
'bcause it's awesome :-)
Submarine has quit [Remote host closed the connection]
<Leonidas>
it breaks in some cases, which sucks
tinhead has quit [Remote host closed the connection]
<Leonidas>
but it leads to pretty nice syntax when your code uses continuations.
<rgrinberg>
@@ fun k -> :P
<Denommus>
what I miss is (.) from Haskell
<Drup>
% in batteries
<Denommus>
cool
<Denommus>
though it's probably not as useful as in Haskell because of the value restriction, right? :P
tinhead has joined #ocaml
sdothum has quit [Quit: ZNC - 1.6.0 - http://znc.in]
<Drup>
yes
Cyanure has quit [Remote host closed the connection]
<Drup>
and because it wouldn't work with labels, and because ocaml don't tend to abuse combinators like flip, uncurry, curry, ...
<Drup>
and because point free just sucks, really. :D
NhanH has quit [Ping timeout: 276 seconds]
<Leonidas>
yes, I don't miss (.) that much
<Denommus>
there are some functions in which I find it easier to reason about the point free version, but it's really not cool to overuse it
NhanH has joined #ocaml
sdothum has joined #ocaml
<Leonidas>
rgrinberg: exactly. Thats rather nice, when your nested continuations don't end ))))))))))) in classic lisp style :-)
<Denommus>
(I'm beginning to want to give up on NetwireOCaml because it's mostly point-free functions for reactive signals)
<Drup>
when I was learning programming, we did a bit of lisp
<Drup>
our teacher was very happy than, in the specific lisp dialect we were using, you could add as many parens as you want at the end
<Denommus>
I like Lisp, but it's very overhyped by its followers
Simn has joined #ocaml
<Denommus>
Drup: the tooling should help you with the parens, to be honest. If the editor doesn't allow you to edit your code as a tree, it's not a good editor for Lisp
<Drup>
like "(f (g x))))))" was valid
<Drup>
Denommus: that's beside the point, I'm just talking about the teacher
<dmbaturin>
Drup: Which lisp dialect was it?
<Leonidas>
Drup: that looks like it'll bite you in the future
<Denommus>
Drup: right
<Drup>
dmbaturin: I don't remember, and I don't really want
<Denommus>
it can't be worse than newLISP
<Denommus>
but that's becoming too off-topic XD
freling has quit [Quit: Leaving.]
<Denommus>
hm, can I print unit with printf?
Algebr has quit [Remote host closed the connection]
<dmbaturin>
I think not.
<Denommus>
ok
<dmbaturin>
I think even ppx_deriving show doesn't have built-in printer for unit, for some reason.
badon has quit [Quit: Leaving]
<dmbaturin>
string_of_unit is not hard to define though. :)
<Denommus>
coffee break
ollehar has quit [Ping timeout: 256 seconds]
Alain has joined #ocaml
badon has joined #ocaml
tinhead has quit [Remote host closed the connection]
ousado has quit [Changing host]
ousado has joined #ocaml
tinhead has joined #ocaml
jonludlam has joined #ocaml
hbar has quit [Ping timeout: 246 seconds]
jita_ has quit []
inf-gropeoid has joined #ocaml
TheLemonMan has quit [Quit: "It's now safe to turn off your computer."]
tane has quit [Quit: Verlassend]
tmtwd has quit [Ping timeout: 252 seconds]
tinhead has quit [Remote host closed the connection]
<nullcat_>
Drup: do u know if js_of_ocaml.compiler can create symbol table?
darnuria has left #ocaml ["WeeChat 1.2-dev"]
<Drup>
what for ?
<nullcat_>
create a symbol table for parsed javascript ast
<Drup>
ah
<nullcat_>
something like JavaScript.program -> symbolTable
<Drup>
I don't know
<Drup>
I don't know jsoo's internals, only the API
<nullcat_>
i am looking at the source code but it seems there is no such thing
<nullcat_>
yeah.. api documentation does not document things in /compiler
<nullcat_>
iirc
Gama11 has quit [Read error: Connection reset by peer]
<Drup>
just ask on the mailing list/bug tracker
<Drup>
hhugo or jerome will answer quickly
<nullcat_>
is github issues ok?
<Drup>
or the mailing list, whichever you prefer
blech_ has joined #ocaml
seanmcl has quit [Quit: My MacBook Pro has gone to sleep. ZZZzzz…]
nullcat_ has quit [Quit: My Mac has gone to sleep. ZZZzzz…]
nullcat_ has joined #ocaml
seanmcl has joined #ocaml
seanmcl has quit [Client Quit]
yomimono has joined #ocaml
wraithm has quit [Quit: leaving]
jpdeplaix has quit [Ping timeout: 256 seconds]
jpdeplaix has joined #ocaml
MrScout has quit [Ping timeout: 256 seconds]
seliopou has quit [Ping timeout: 256 seconds]
ingsoc has quit [Quit: Leaving.]
seliopou has joined #ocaml
JuggleTux has joined #ocaml
Simn has quit [Quit: Leaving]
ollehar has joined #ocaml
leafac has joined #ocaml
thomasga has quit [Quit: Leaving.]
tinhead has joined #ocaml
tinhead has quit [Changing host]
tinhead has joined #ocaml
amnn has quit [Quit: My MacBook Pro has gone to sleep. ZZZzzz…]
amnn has joined #ocaml
<j0sh>
is there a way to curry (or partially apply) a function that has labelled/optional arguments?
Alain has quit [Ping timeout: 246 seconds]
<j0sh>
for example, this does not seem to be do-able: let log_debug = Lwt_log.debug_f ~section
<Drup>
how is it not possible ?
jonh has left #ocaml ["WeeChat 0.4.2"]
<Drup>
(it should work just fine)
<nullcat_>
let f ~x ~y = x - y;; let g = f ~y:3
<nullcat_>
labeling argument helps you to do currying