emmanuelux has quit [Remote host closed the connection]
Yoric has joined #ocaml
ulfdoz_ has joined #ocaml
ulfdoz has quit [Ping timeout: 265 seconds]
ulfdoz_ is now known as ulfdoz
<jonafan>
Are BatEnum.ts supposed to be used one time only?
Yoric has quit [Ping timeout: 265 seconds]
dwmw2_gone has quit [Ping timeout: 260 seconds]
<_habnabit>
jonafan, well, they can be fully consumed. it depends on what you mean by 'one time only'
<_habnabit>
jonafan, are you having an issue?
weie has joined #ocaml
madroach has quit [Ping timeout: 244 seconds]
madroach has joined #ocaml
eikke has quit [Ping timeout: 248 seconds]
mildfate has joined #ocaml
<mildfate>
This expression: "fun x -> x 1" has type (int -> 'a) -> 'a. What does this mean? Where in the expression is "a function that takes an int and returns something of type a which returns something of type a"?
mattrepl has joined #ocaml
dskippy has quit [Ping timeout: 248 seconds]
Submarine_ has joined #ocaml
mye has joined #ocaml
myx has quit [Ping timeout: 276 seconds]
<_habnabit>
mildfate, (int -> 'a) is a function that takes an int and returns something
<_habnabit>
mildfate, the parentheses are used to disambiguate it from int -> 'a -> 'a, which is a function that takes two arguments and returns something that's the same type of the second argument
justdit has joined #ocaml
mye_ has joined #ocaml
mye has quit [Ping timeout: 250 seconds]
mye_ is now known as mye
Yoric has joined #ocaml
fayden has joined #ocaml
BiDOrD_ has joined #ocaml
BiDOrD has quit [Ping timeout: 248 seconds]
Yoric has quit [Remote host closed the connection]
Submarine_ has quit [Read error: Operation timed out]
jewel has joined #ocaml
Snark has joined #ocaml
Cyanure has joined #ocaml
mattrepl has quit [Quit: mattrepl]
jewel has quit [Ping timeout: 264 seconds]
Submarine_ has joined #ocaml
Submarine_ has quit [Changing host]
Submarine_ has joined #ocaml
Submarine_ has quit [Ping timeout: 260 seconds]
<areece>
do types have to start with a lowercase letter?
<areece>
as in type foo = int
<areece>
rather than type Foo = int
Cyanure has quit [Remote host closed the connection]
pango is now known as pangoafk
<_habnabit>
areece, yes
<_habnabit>
areece, modules and the type instance names (i.e. in `type foo = A | B`) must start with an uppercase letter and every other identifier must start with a lowercase letter
<areece>
ok, thanks
cdidd has joined #ocaml
hkBst has joined #ocaml
djcoin has joined #ocaml
Cyanure has joined #ocaml
weie_ has joined #ocaml
weie has quit [Ping timeout: 250 seconds]
dwmw2_gone has joined #ocaml
cago has joined #ocaml
mika1 has joined #ocaml
thomasga has joined #ocaml
madroach has quit [Ping timeout: 244 seconds]
fusillia has joined #ocaml
madroach has joined #ocaml
ftrvxmtrx has joined #ocaml
ocp has joined #ocaml
paolooo has joined #ocaml
|jbrown| has quit [Ping timeout: 265 seconds]
|jbrown| has joined #ocaml
ontologiae has joined #ocaml
eikke has joined #ocaml
mfill has joined #ocaml
mika1 has quit [Quit: Leaving.]
mika1 has joined #ocaml
paolooo has quit [Quit: Page closed]
chambart has joined #ocaml
<yezariaely>
Is there a possibility to say that a module follows two or more type signatures? module MyModule : S1,S2,S3 = struct
<yezariaely>
or do I have to write module type S1ToS3 = sig include S1 include S2 include S3 end ?
<thizanne>
a module is not only a "struct", it is inseparable from its signature
<thizanne>
therefore two different signatures can only relate to two different modules
<thizanne>
oh, forget that
<thizanne>
I didn't get it
<thizanne>
yezariaely: I think module MyModule : sig include S1 include S2 include S3 end = struct ... should work
Submarine_ has joined #ocaml
Submarine_ has quit [Changing host]
Submarine_ has joined #ocaml
<yezariaely>
ah nice. Thanks!
Submarine_ has quit [Client Quit]
milosn has quit [Ping timeout: 244 seconds]
hkBst has quit [Ping timeout: 250 seconds]
hkBst has joined #ocaml
beckerb has joined #ocaml
mika1 has quit [Quit: Leaving.]
pangoafk is now known as pango
larhat has joined #ocaml
hkBst has quit [Ping timeout: 255 seconds]
hkBst has joined #ocaml
hkBst has quit [Changing host]
hkBst has joined #ocaml
percival has quit [Ping timeout: 245 seconds]
_mdp has joined #ocaml
ikaros has joined #ocaml
justdit has quit [Ping timeout: 264 seconds]
answer_42 has joined #ocaml
<pippijn>
has anybody used the Ohm web framework?
ontologiae has quit [Ping timeout: 255 seconds]
groleo has left #ocaml []
Cyanure has quit [Ping timeout: 245 seconds]
mika1 has joined #ocaml
Cyanure has joined #ocaml
justdit has joined #ocaml
ontologiae has joined #ocaml
<adrien_oww>
I'm resisting it!
<pippijn>
why?
<adrien_oww>
bad pun :P
<djcoin>
huhu
<pippijn>
ah
<Qrntz>
heh
beginner42 has joined #ocaml
<beginner42>
how can i encode a record type with yojson?
Cyanure has quit [Remote host closed the connection]
bru` has joined #ocaml
<pippijn>
beginner42: as Assoc
<pippijn>
beginner42: `Assoc of (string * json) list
<beginner42>
pippijn: string is the identifier?
<pippijn>
yes
bru` has quit [Ping timeout: 246 seconds]
hkBst has quit [Ping timeout: 245 seconds]
hkBst has joined #ocaml
hkBst has quit [Changing host]
hkBst has joined #ocaml
jbrown__ has joined #ocaml
|jbrown| has quit [Ping timeout: 260 seconds]
troydm has joined #ocaml
<troydm>
so i'm going to write some my own research project in order to learn ocaml so i was thinking what build system should i use
<troydm>
it there some build system for Ocaml ?
<troydm>
that would be easy to configure and use for building projects
<pippijn>
ocamlbuild
<beginner42>
pippjin: i tried `List [`Assoc ("test", `String "test2)], but then Yojson.to_string of that does not work
flux has quit [Remote host closed the connection]
<pippijn>
beginner42: what is the error?
<pippijn>
did it even compile?
<beginner42>
pippjin: i get this
<beginner42>
Error: This expression has type [> `List of ([> `Assoc of string * [> `String of string ] ] as 'a) list ] but an expression was expected of type Yojson.json = [ `Assoc of (string * Yojson.json) list | `Bool of bool | `Float of float | `Floatlit of string | `Int of int | `Intlit of string | `List of Yojson.json list
<pippijn>
right
<pippijn>
try replacing the ( and ) with [ and ]
<beginner42>
pippjin: like `List [`Assoc ["test"; `String "test2"]] ?
<pippijn>
who told you to replace , with ;?
<beginner42>
pippijn: my mistake
<beginner42>
pippjin: but now it works
<beginner42>
thanks
flux has joined #ocaml
<pippijn>
beginner42: in the future, could you spell my name correctly?
larhat has quit [Quit: Leaving.]
<beginner42>
pippijn: sorry, will do
Kakadu has joined #ocaml
<orbitz>
when you define a type for a plymorphic variant, should you do [ `Foo ]? or [> `Foo ]?
gnuvince has quit [Ping timeout: 265 seconds]
<pippijn>
I want to write a webapp that works by responding to GET and POST requests with JSON responses
<orbitz>
I'm working on a web framework sort of, in my random cycles
<pippijn>
I would like to have something like spring for ocaml
<orbitz>
I don't know anything about spring
<pippijn>
but more decoupled from the actual transport
<pippijn>
spring is an MVC framework
<pippijn>
it includes security, AAA, ...
<orbitz>
My initial phase will not be much more than an HTTP transport and it will call your callback modules
<orbitz>
and then you can do pretty much anything from there
mfill has quit [Quit: Lost terminal]
metasyntax|work has quit [Quit: WeeChat [quit]]
lihaitao has joined #ocaml
lihaitao is now known as lht
<troydm>
can i do something like this?
<troydm>
type vector = float * float * float
<pippijn>
troydm: what happens when you do it?
<troydm>
well i have it defined in my .ml file
<troydm>
but it says
<troydm>
Error: Syntax error
<troydm>
wait sorry
<troydm>
file was unsaved
<gasche>
troydm: for performances and readability you should rather use a record: type vector = { x : float; y : float; z : float }
<gasche>
(records with only float members are optimized specifically)
<troydm>
tuples don't ?
<gasche>
(giving premature-optimization advice is usually not my cup of tea, but I guess you're planning to do some physical simulation where performance may matter)
<troydm>
i'm having hard type understanding syntax :(
<pippijn>
let v1 = {...} in
<pippijn>
not
<pippijn>
let v1 = {...};
smondet has joined #ocaml
<troydm>
ic, thx
myx has joined #ocaml
<troydm>
is there a quick way to print out record into stdout ?
<troydm>
or i should implement some function and use it
<pippijn>
troydm: in the ocaml debugger, you can do it
<pippijn>
troydm: or in the ocaml toplevel
<troydm>
pippijn: so what's the guidline for serialization?
<pippijn>
troydm: otherwise, you can use something like deriving-ocsigen (Show/Dump) or sexplib
<troydm>
like i know in haskell there is deriving Show operator
<pippijn>
yes, there is a syntax extension for deriving Show
<troydm>
pippijn: ic, some external variables
<troydm>
*external libraries
<pippijn>
yes
gnuvince has quit [Ping timeout: 255 seconds]
myx has quit [Ping timeout: 255 seconds]
hkBst_ has joined #ocaml
hkBst has quit [Ping timeout: 248 seconds]
mattrepl has joined #ocaml
gnuvince has joined #ocaml
bru` has joined #ocaml
mika1 has quit [Quit: Leaving.]
mika1 has joined #ocaml
bru` has quit [Ping timeout: 265 seconds]
mattrepl_ has joined #ocaml
mattrepl has quit [Ping timeout: 248 seconds]
mattrepl_ is now known as mattrepl
mika1 has quit [Quit: Leaving.]
mika1 has joined #ocaml
ocp has quit [Quit: Leaving.]
<pippijn>
eliom does exactly what I don't want
<pippijn>
"The tightest integration of client value within the server code ever made possible in a major statically typed programming language [1]"
<thelema>
pippijn: you don't want the client values to be known to the server?
<pippijn>
no
<pippijn>
I don't
<pippijn>
I want to decouple the two
<pippijn>
I can see advantages in eliom's paradigm
<thelema>
I think the idea behind eliom is that you write one thing, and eliom breaks it into server/client, with as loose coupling as possible
<pippijn>
but I don't want this now
<pippijn>
thelema: yes
<pippijn>
but I have a frontend guy
<pippijn>
and that guy is not me
<thelema>
presentation != logic
<thelema>
I assume your frontend guy will handle presentation
<pippijn>
yes
<pippijn>
and I don't want to have anything to do with presentation
<thelema>
but that you're going to be responsible for how things work
<pippijn>
I feed him data in the way he can use it
<pippijn>
so my data is molded into presentable forms
<thelema>
eliom has a template language, I assume; the frontend guy can use that.
<pippijn>
but how exactly it is shown is not for me
mika1 has quit [Quit: Leaving.]
<pippijn>
ah, that's nice
cago has left #ocaml []
<thelema>
:(
<thelema>
Eliom does not say anything about the way to create pages. The only thing it does it to make possible the static typing of pages through various modules. There is no template system by default in Ocsigen but it would not be very difficult to plug one in Eliom if you do not want static validation of xhtml. We are working on a high level template system allowing to write kind of templates, but without loosing static typing of pages and modularity.
<thelema>
apparently the template system is TODO.
Kakadu has quit []
<pippijn>
but the problem with "writing one thing" is that you can't write "another thing" that consumes server functionality
<pippijn>
like a non-web-app
<pippijn>
or maybe another web-app where the server side communicates with the web-app
fusillia has quit [Ping timeout: 245 seconds]
mildfate has quit [Quit: Leaving.]
justdit has quit [Ping timeout: 252 seconds]
jamii has joined #ocaml
ftrvxmtrx has quit [Quit: Leaving]
mildfate has joined #ocaml
tac has joined #ocaml
answer_42 has joined #ocaml
Neros has joined #ocaml
myx has joined #ocaml
hkBst_ has quit [Quit: Konversation terminated!]
tac has quit [Quit: Page closed]
tac has joined #ocaml
<troydm>
should i change all references of getbufvar('%','var') to b:var ?
<troydm>
in my viml ?
* thelema
has no idea
<troydm>
ups sorry wrong channel :)
bru` has joined #ocaml
gnuvince has quit [Ping timeout: 244 seconds]
Kakadu has joined #ocaml
beckerb has quit [Quit: Konversation terminated!]
justdit has joined #ocaml
jamii has quit [Ping timeout: 245 seconds]
justdit has quit [Ping timeout: 244 seconds]
tane has joined #ocaml
milosn has joined #ocaml
jewel has joined #ocaml
inv has joined #ocaml
Xizor has joined #ocaml
thomasga has quit [Quit: Leaving.]
ontologiae has quit [Ping timeout: 244 seconds]
thomasga has joined #ocaml
thomasga has quit [Client Quit]
gnuvince has joined #ocaml
eikke has quit [Ping timeout: 248 seconds]
Submarine has joined #ocaml
Submarine has quit [Changing host]
Submarine has joined #ocaml
srcerer_ has joined #ocaml
<jonafan>
okay, i wrote a neat batteries program
<jonafan>
but my code is very Bat___.blah BatThing.Empty BatArray.enum
srcerer has quit [Ping timeout: 246 seconds]
srcerer_ is now known as srcerer
<thelema>
jonafan: 'open Batteries'
<thelema>
(unless you're using 1.x, then 'open Batteries_uni')
<thelema>
this gets rid of all the Bat prefixes
<jonafan>
hmm, okay i need to make adjustments now
dskippy has joined #ocaml
srcerer has quit [Read error: Connection reset by peer]
srcerer has joined #ocaml
<jonafan>
hmm, cannot link anymore
<jonafan>
my _tags must now be inadequate
<thelema>
what's the link error?
<thelema>
and what version of batteries?
<jonafan>
Reference to undefined global `Batteries'
<jonafan>
batteries is 1.5.0
<thelema>
if you're using 1.x, 'Batteries' is only available if you compile with threads
<jonafan>
oh i see
<thelema>
Batteries_uni is needed for no threads
lihaitao is now known as lht
<thelema>
'open Batteries_uni'
<dskippy>
I am looking for an OCaml library that will setup a mainloop for my program and allow me to schedule callbacks (aka timeouts in GObject) that are called once in the future or periodically every minute, etc.
<thelema>
dskippy: lablgtk2?
<dskippy>
I wrote something similar to this in Python using GObject.
<dskippy>
thelema: Possibly. It's not a GUI program but that might be the best option.
<jonafan>
okay that's a bit better
<dskippy>
Does anyone know about OCaml-event and if that is any good?
lolcathost has joined #ocaml
<jonafan>
figuring out the best module to open is a bit of a black art
<thelema>
jonafan: it's a weakness in batteries' documentation
<thelema>
luckily this is fixed in 2.0, where 'open Batteries' always works
<jonafan>
well, now i'm trying to open like List and Char and stuff
<jonafan>
but some things shadow other things so it's trial and error
<jonafan>
more of a general ocaml problem
<thelema>
jonafan: ah. try to open as few things as possible. It's not so bad typing List.enum, etc...
<thelema>
If you want shorter, you can do `module L = List`, and people will generally understand.
<thelema>
warning: do this after 'open batteries'
<jonafan>
maybe that'd be better
lolcathost has quit [Ping timeout: 244 seconds]
lht has quit [Quit: Ex-Chat]
jamii has joined #ocaml
milosn_ has joined #ocaml
<jonafan>
batteries' print functions are awesome
milosn has quit [Ping timeout: 265 seconds]
<thelema>
jonafan: Foo.print, right? 1.5 also has a camlp4-enabled printing infrastructure that's being dropped for 2.0 (along with the rest of the camlp4)
<jonafan>
Yeah, like List.print Int.print stdout nums
<thelema>
yes, it's what I use for all my printing.
<thelema>
Are you aware of %a?
<jonafan>
no
<thelema>
|> tap (Printf.printf "Final Grammar:\n%a\n" Ns_parse.print_reg_ds_ca_flat)
<jonafan>
whaaaat
<thelema>
|> is normal pipe operator
<jonafan>
yeah i got that
<thelema>
'tap' is an odd function: tap f x = f x; x
<thelema>
meaning apply this function to the input, and return the input again
<inv>
thelema: thank you! exactly what I was looking for
<thelema>
inv: you're welcome
chambart has quit [Ping timeout: 255 seconds]
<troydm>
how do i define a record inside module ?
<troydm>
put type definition into module A : sig
<troydm>
e.g. .mli file ?
jewel has quit [Ping timeout: 276 seconds]
<thelema>
module A : sig type record = {a : int; b: string} end
<thelema>
same as in the .ml file
<thelema>
is your problem *records* or *nested module types*?
emmanuelux has joined #ocaml
<thelema>
x.ml: type r = {a:int; b:string} module A = struct type r2 = {c:float; d: char array} end
<thelema>
x.mli: type r = {a:int; b:string} module A : sig type r2 = {c:float; d:char array} end
* wmeyer`
also thinks that we should have 'type rec'
<thelema>
(untested, but this should be correct)
wmeyer` is now known as wmeyer
<thelema>
wmeyer`: type is already recursive
<troydm>
thelema: record i guess
<wmeyer>
thelema: but the idea is to not make it recursive
<thelema>
type declarations are the same syntax in .ml as in .mli
<thelema>
wmeyer: You want 'type notrec t = t'?
<troydm>
so to define a record i need to put it's definition in both .ml and .mli file?
<wmeyer>
thelema: yes
<thelema>
troydm: in the beginning, you don't need .mli files at all.
<thelema>
they're good practice for larger projects, and a good place to hang documentation.
<troydm>
thelema: hmm i'm trying to break my functionality into modules
<thelema>
first make things work without .mli files
<thelema>
then add .mli files one at a time to nail down exposed values.
<troydm>
i do include Modulename in my .ml file
<wmeyer>
troydm: ocamlbuild path/file.inferred.mli && cat _build/path/file.inferred.mli is your friend
<troydm>
in order to use type vector defined in .mli
<troydm>
is this right way to do it?
<thelema>
yes, you'll need x.Module.field to access record field defined in Module
<thelema>
better than 'include Modulename' is "open Modulename", which just imports the symbols and doesn't re-export them.
<troydm>
now i'm confused
<wmeyer>
troydm: `include' and `open' are different. `include' has similar semantics to #include in C, textual inclusion (it's not but it feels like), `open' just brings the module contents into scope.
<troydm>
i kinda thought .mli file is just like .h in C
<thelema>
troydm: sorry, I answered confusingly
<troydm>
thelema: no, it's ok
<thelema>
no, .mli file is only like .h in C in that it has type and function declarations
<wmeyer>
troydm: yes, but there are fundamental differences. You really don't want it to be like 'h :-)
<thelema>
in C, .h files are #included, which is not at all how ocaml works
<wmeyer>
troydm: #include "header.h" is the worst thing that happen to C++.
<adrien>
nah
<troydm>
so i have a type vector
<adrien>
#include <implementation.c>
<adrien>
is way worse :P
<adrien>
(I used < and > on purpose ;p )
<troydm>
and i have an infix operation of adding two vectors together
<wmeyer>
adrien: sure :D
<thelema>
troydm: try to avoid both 'include' and 'open'.
<troydm>
now what's correct way to put it into .ml and .mli files?
<thelema>
ah, except for infix operators
<thelema>
for them, easiest is to just 'open Foo'
<thelema>
and then just use
<troydm>
thelema: that's what i need
<thelema>
for other functions, just prefix use by module name: List.length
<troydm>
i only need an module to work with vectors
<troydm>
so how do i put it correctly
<troydm>
i did put a definition in .mli
hongboz has joined #ocaml
<troydm>
and then did include Vector in .ml file
<troydm>
but it seems
<thelema>
Better than this is to have all your infix operators in a submodule, i.e. Vector.Infix, and do 'open Vector.Infix' to just include those values.
<wmeyer>
thelema: some people would argue.
<thelema>
step 1: remove your .mli files (or move them somewhere else)
<thelema>
wmeyer: really?
<wmeyer>
thelema: but i agree with you and in general
<wmeyer>
there was some discussion long time ago on mantis about having the infix operators for each of the numerical modules in stdlib. These days I tend to agree that stdlib should not include them.
<thelema>
'include Vector' will work, but should be replaced by 'open Vector' when possible (which is 99% of the time)
<wmeyer>
troydm: include is like inheritance in Java or C++
<troydm>
wmeyer: ic
<troydm>
wmeyer: so what's module A : sig then ?
<wmeyer>
use it when you want to extend something
<wmeyer>
that's a signature of w nested module
<thelema>
troydm: "module A : sig ... end" is for .mli files where there's a submodule A, like the Infix module I mentioned earlier
mildfate has quit [Quit: Leaving.]
answer_42 has quit [Quit: WeeChat 0.3.9.2]
<troydm>
now i'm lost :)
<troydm>
so you can define like simple functions in module
<wmeyer>
you need to find similarities it's was not obvious for C++ programmer before to me too
<wmeyer>
: sig is like type annotation for module
<wmeyer>
you can have it in ml file but don't need to
<wmeyer>
also, you can name signatures as signature types
<wmeyer>
module type TYPE_OF_MODULE = sig ... end
<wmeyer>
vs
<wmeyer>
module A : sig end = struct end
<wmeyer>
then you can use this signature
<wmeyer>
module A : TYPE_OF_MODULE = struct end;
<wmeyer>
s/;/;;/g
<troydm>
ic, thx
<troydm>
i think i'm not kinda begging to understand it
<wmeyer>
troydm: it's simple and extremely consistent
<wmeyer>
to that level that poeple just think it's black magic
<wmeyer>
with a Java or C++ background
Snark has quit [Quit: Quitte]
<troydm>
definition syntax makes it all confusing :(
gnuvince has quit [Ping timeout: 244 seconds]
<thelema>
troydm: you don't need .mli files at all; don't make your life more complex.
<troydm>
yeah that's the first impression i kinda get
<wmeyer>
troydm: the mli file is the last step
<wmeyer>
thelema: I concur what thelema says, don't make your life complex with mli file!
ontologiae has joined #ocaml
srcerer_ has joined #ocaml
zzz_ has joined #ocaml
tizoc` has joined #ocaml
srcerer has quit [Disconnected by services]
srcerer_ is now known as srcerer
dsheets1 has joined #ocaml
emmanuelux has quit [*.net *.split]
jamii has quit [*.net *.split]
Submarine has quit [*.net *.split]
dsheets has quit [*.net *.split]
brendan has quit [*.net *.split]
zzz_` has quit [*.net *.split]
tizoc has quit [*.net *.split]
willb has quit [*.net *.split]
tac has quit [Ping timeout: 245 seconds]
patronus1 has joined #ocaml
sgnb` has joined #ocaml
emmanuelux has joined #ocaml
willb has joined #ocaml
jamii has joined #ocaml
NaCl_ has joined #ocaml
NaCl_ has quit [Changing host]
NaCl_ has joined #ocaml
mildfate has joined #ocaml
adrien_ has joined #ocaml
wagle_ has joined #ocaml
Submarine has joined #ocaml
Submarine has quit [Changing host]
Submarine has joined #ocaml
tizoc` is now known as tizoc
rixed_ has joined #ocaml
tizoc has quit [Changing host]
tizoc has joined #ocaml
teamon_ has joined #ocaml
mattrepl_ has joined #ocaml
brendan has joined #ocaml
mattrepl has quit [*.net *.split]
fayden has quit [*.net *.split]
rixed has quit [*.net *.split]
wagle has quit [*.net *.split]
sgnb has quit [*.net *.split]
teamon has quit [*.net *.split]
avsm has quit [*.net *.split]
adrien has quit [*.net *.split]
patronus_ has quit [*.net *.split]
NaCl has quit [*.net *.split]
mattrepl_ is now known as mattrepl
mildfate has quit [Quit: Leaving.]
fayden has joined #ocaml
Neros has quit [Ping timeout: 264 seconds]
wagle_ is now known as wagle
avsm has joined #ocaml
tac has joined #ocaml
weie_ has quit [Quit: Leaving...]
Neros has joined #ocaml
hongboz has quit [Ping timeout: 260 seconds]
chambart has joined #ocaml
areece is now known as not_areece
not_areece is now known as areece
eikke has joined #ocaml
Kakadu has quit [Ping timeout: 264 seconds]
ontologiae has quit [Quit: Lost terminal]
sivoais has quit [Read error: Operation timed out]
gnuvince has joined #ocaml
Cyanure has joined #ocaml
myx has quit [Ping timeout: 265 seconds]
Cyanure has quit [Ping timeout: 248 seconds]
Cyanure has joined #ocaml
bru` has quit [Ping timeout: 244 seconds]
djcoin has quit [Quit: WeeChat 0.3.9.2]
smondet has quit [Ping timeout: 260 seconds]
Xizor has quit []
arsatiki has quit [Remote host closed the connection]
emmanuelux has quit [Remote host closed the connection]
<pippijn>
I really like the fact that you need to write "let rec" for recursive functions
<pippijn>
it's a strong indication for "this function does not call itself"
<thelema>
not too important to me.
<ben_zen>
pippijn: well it's part of how the language is parsed, if I understand it correctly.
<pippijn>
I like it
<pippijn>
I use java at work
<ben_zen>
erg. Java.
<thelema>
ben_zen: not quite a parsing difference, just a scoping one
<ben_zen>
thelema: mm, yes.
<pippijn>
and the methods are all over the place
<ben_zen>
pippijn: the data structures course I'm taking next semester (Algs and Data Structures) is Java-based
<pippijn>
I like that in ocaml, you have definition before use
<pippijn>
ben_zen: my algs course has no programming language
<pippijn>
the algs lab was java-based, though
<pippijn>
the programming concepts course uses haskell
<ben_zen>
pippijn: we have no labs; algorithms are discussed in pseudocode and then implemented in Java (which was apparently decided upon for ease of debugging.)
<ben_zen>
(or something. I'm not really sure.)
tane has quit [Quit: Verlassend]
tac has quit [Ping timeout: 245 seconds]
chambart has quit [Ping timeout: 246 seconds]
sivoais has joined #ocaml
ikaros has quit [Quit: Ex-Chat]
Cyanure has quit [Remote host closed the connection]