00:19 <discocaml> <tym972_45887> Hello, I'm writing a chess program in OCaml. For now, I'm using integer arrays to represent the chessboard (mailbox). Do you think it's possible to replace these arrays with bitboards (sets of int64s) - possible in the sense that speed elo is gained? Or do you think it's a waste of time and that I should switch languages?

00:25 <discocaml> <yawaramin> why wouldn't it be possible? OCaml has int64 with logical operations, you can definitely implement a bitboard if you want

00:29 <discocaml> <tym972_45887> The best other OCaml program I've found uses bitboards. Its move generation speed is truly disastrous compared to mine. I haven't really looked into it, but maybe he's done it wrong.

00:31 <discocaml> <tym972_45887> The best other OCaml program I've found uses bitboards. Its move generation speed is truly disastrous compared to mine. I haven't really looked into it, but maybe he's done it wrong or I'm using his program incorrectly.

02:08 <sleepydog> an `int64 array` has an extra layer of indirection compared to an `int array`, that could affect how well your program utilizes the cpu cache

02:10 <discocaml> <Kali> an int64 *big*array avoids this, i think

02:15 <sleepydog> or even `bytes` with the get/set_int64_ne functions

05:00 <discocaml> <shadowkestrel> iirc this is how some part of Stdlib (i think CamlinternalFormatBasics?) handles char sets - since 256 is a relatively small number of bits, it uses a string (or bytes) as a bitset

08:47 <discocaml> <mostafa_touny> https://discuss.ocaml.org/t/emulating-type-classes-in-ocaml/17092

08:47 <discocaml> <mostafa_touny> I suggest to add we a **Design Patterns** entry on OCaml's doc. Emulating **Type-Classes** is a common problem, and multiple solutions are suggested including **Open Variants**, **Functors**, and **Runtime Dispatch**.

08:47 <discocaml> <mostafa_touny> Is anyone aware of any resource close to such design patterns for OCaml?

08:48 <discocaml> <mostafa_touny> Is anyone aware of any resource close to such design patterns for OCaml? If not, then I suggest we add an entry for them on OCaml's doc.

08:48 <discocaml> <mostafa_touny> Emulating **Type-Classes** is a common problem, and multiple solutions are suggested including **Open Variants**, **Functors**, and **Runtime Dispatch**.

08:48 <discocaml> <mostafa_touny> Emulating **Type-Classes** is a common problem, and multiple solutions are suggested including **GADTs**, **Open Variants**, **Functors**, and **Runtime Dispatch**.

11:22 <discocaml> <shalokshalom> Maybe start, by evaluating what you think you need it for.

11:22 <discocaml> <shalokshalom> It's amazing, how people dribble around multiple dispatch.

13:55 <discocaml> <yawaramin> sleepydog: a bitboard is a single int64, not an array

14:12 <discocaml> <bluddy5> Feel free to submit an article on ocamlverse.net

14:13 <discocaml> <bluddy5> But it's still heap allocated. If the point is running as fast as possible, int64 will probably not get you there. He might want to try out #oxcaml .

14:34 <sleepydog> you need multiple bitboards to make up a chessboard, no? i must admit i know nothing about chess engines

14:39 <discocaml> <yawaramin> neither do i, i am going off Wikipedia 😁

17:11 <discocaml> <froyo> intuitively a chess board has 64 cells, so assuming a bit indicates whether or not a piece is on a cell, you just can't represent the info of *which* piece is it without having multiple views of the same board per piece kind (so six bitboards)

17:30 <discocaml> <froyo> is a 32-char bytes small enough to encode a chessboard without relying on oxcaml? each char would represent a piece (3+3bits for coords, 1 bit for alive or not), and its index would represent its type (4 bits for kind, 1 bit for color).

17:31 <discocaml> <froyo> that's the smallest encoding I could come up with

17:33 <Anarchos> froyo yes it seems

17:33 <Anarchos> froyo you even have an extra-bit per char :)

17:34 <discocaml> <froyo> so it's valid ascii of course :P

17:56 <discocaml> <bluddy5> from what I read, you also want to make sure you're activating the right bit-level x86 (or ARM) operations to make things efficient.

17:57 <discocaml> <bluddy5> I don't know if ocaml supports those.

18:40 <discocaml> <shadowkestrel> ive never seen ocamlopt output simd operations in godbolt, i have a feeling it just cant output them? but id need to look inside the compiler's source to say for sure, and that would be effort

18:50 <discocaml> <froyo> but how often would you need to do an operation on the board in bulk? and wouldn't `int * int * int * int` or `bytes`suffice really? it's worth implementing and measuring before reaching for simd

18:52 <discocaml> <froyo> idk how engines work, but if it's turn by turn etc then at most you're working with one of those `int`s at a time

18:55 <discocaml> <yawaramin> yeah i guess the main question is what is the performance requirement

18:55 <discocaml> <yawaramin> like do they need to generate a move in a few microseconds or something

19:58 <companion_cube> You probably want bytes instead of a tuple