09:40 <Anarchos> I made a pull request in order to let ocaml install on Haiku 64 bits (x86/amd)

11:48 <d_bot> <Bluddy> what's the deal with Haiku? What is it for?

12:27 <d_bot> <Bluddy> sorry for the non-sequitur, but I'm genuinely curious

12:32 <Anarchos> i need help about porting dune to an architecture without wait3()

18:03 <d_bot> <monk> what would be the simplest approach to writing parser combinators using ocaml's stdlib? would composing them out of scanf make sense?

18:03 <companion_cube> the simplest approach is to use a library :D

18:03 <d_bot> <monk> not looking for sophistication, more for just learning the general premise/strategy

18:04 <companion_cube> (but no, scanf is most likely a bad idea, even in C)

18:04 <d_bot> <monk> wait, so scanf is bad idea with ocaml

18:04 <d_bot> <monk> for this at least

18:05 <companion_cube> well, for a start, you'd need scanf to work on string slices, not a full string

18:05 <companion_cube> scanf can be useful in very small parts (like, you read a hexadecimal number some other way, get a substring, and then use `sscanf thesubstring "%x" (fun x->x)` or sth like that)

18:45 <Drup> honestly, using scanf is not a very good idea in general

18:57 <kvik> i always found it... curious, how performing a seemingly basic task of working with input data just about requires a computeering degree. you better not use this thing (scanf) that claims it does what you want. you better not write your own scanner because it'll be brittle (say in c) and the errors will suck. you better not import this framework of a library because... etc.

18:57 <kvik> moral of the story: computers are terrible listeners

19:01 <companion_cube> something like angstrom is basically a scanner framework, I think

19:01 <companion_cube> it does lack stuff to read integer or float literals

19:15 <Corbin> Workflow question: I have an expression that I want to typecheck in a context; like, I have a #use that I give to utop, and get the context all set up, and then I ask utop to tell me the type of some fun.

19:16 <Corbin> Is there a more ergonomic way to do this than to go through a toplevel prompt, given that most/all of the context is in a .ml file already?

19:17 <companion_cube> install merlin/ocamllsp, use the key binding for "type of expression"

19:17 <companion_cube> + under cursor

19:35 <d_bot> <monk> yeah I basically wanted to roll a naive and smaller subset of angstrom parser combinatory

19:35 <d_bot> <monk> Combinators*

19:37 <companion_cube> can't blame you, I did that as well

19:52 <Corbin> companion_cube: That's acceptable. Is there a programmatic way to do it? I guess I don't know what a programmatic handling of types would look like, but I'm interested in what other folks do.

19:54 <companion_cube> oh, hmm, I use tools, I don't write them :/

19:54 <companion_cube> I imagine you use emacs, no? :D

19:59 <Corbin> I use vim (grew up on the West Coast), but what I'd like to do is take snippets of compiled-towards-OCaml code and compose them with type-correct frontends in an automatic way. I was hoping not to involve myself in the process.

20:00 <Corbin> (I am looking at integrating Merlin right now, but I don't normally do tab-completion in editors, so I'm not sure if I'd benefit much. It is quite nifty, for sure.)

20:00 <companion_cube> hmm that sounds hard :p

20:00 <companion_cube> don't use it for tab completion, use it for goto-def and fast type errors return

21:41 <d_bot> <Alistair> Whats the best way of getting the rewritten AST of test file using a local ppx rewriting (build w/ dune)?

21:52 <companion_cube> I have no idea, I'd look in _build/…

22:23 <d_bot> <monk> wondering how dumb it would be to try rolling parser combinators as described in the hutton & meijer paper

22:28 <companion_cube> is that in Haskell?

22:31 <d_bot> <monk> yeah but it's not really advanced haskell, it's pretty legible and comes across as something easily transcribed

22:32 <d_bot> <monk> https://www.cs.nott.ac.uk/~pszgmh/monparsing.pdf

22:34 <d_bot> <monk> do not mistake me for someone comfortable in haskell or programming generally, fyi lol

23:00 <companion_cube> it's not going to be easily transcribed because of lazyness, I'm afraid

23:26 <d_bot> <monk> didn't occur to me 😦

23:28 <companion_cube> Also it might be on lists of chars

23:30 <d_bot> <monk> i actually figured that part not really avoidable

23:30 <d_bot> <monk> at least for how i figured it

23:31 <d_bot> <monk> the goal really wouldn't be so much about efficiency as it would be figuring it out

23:37 <d_bot> <Alistair> If you’re looking for simple monadic parser combinators try: https://github.com/pyrocat101/opal

23:38 <d_bot> <monk> wow that's exactly the style of code i had in mind

23:38 <d_bot> <monk> 150 lines

23:39 <d_bot> <monk> dang

23:39 <d_bot> <Alistair> If you’re planning on using parser combinatory in a library tho, would recommend angstrom

23:40 <d_bot> <Alistair> https://github.com/inhabitedtype/angstrom

23:40 <d_bot> <monk> nah it was going to be for a dumb small programming language implementation

23:40 <d_bot> <monk> the hope was to roll them myself

23:40 <d_bot> <monk> angstrom looks very nice, i have nothing against it

23:41 <d_bot> <monk> was just hoping i could figure out (if very naive and inefficient) ocaml flavored parser combinators on my own 😭

23:41 <d_bot> <monk> sigh

23:43 <d_bot> <Alistair> I mean I think the translation from Haskell to ocaml shouldn’t be too bad (modulo type classes etc), I remember doing it for some supo work a couple months ago (will check if I ran into anything now)

23:44 <companion_cube> @monk you could also look at CCParse in containers, it's internediate complexity I'd say

23:51 <d_bot> <Alistair> I just checked, translation was fine (used `Sequence` from `Base` for my lazy input stream)

23:55 <d_bot> <monk> are lazy streams a pattern that are explored somewhere?

23:55 <d_bot> <monk> this comes up as a result and seems good https://www.cs.cornell.edu/courses/cs3110/2018sp/l/12-streams/notes.html

23:56 <d_bot> <monk> it's obvious in retrospect but i would have absolutely owned myself without seeing the opal impl at top

23:56 <d_bot> <monk> and feel kinda dumb for that one lol

23:57 <d_bot> <monk> i will def checkout

23:57 <d_bot> <monk> thank you