00:01 <discocaml> <darrenldl> neiluj: defining the corresponding let operators make error handling through result relatively painless, so i use it pervasively

09:46 <discocaml> <darrenldl> i got my mind blown learning about visitor pattern in oop

09:53 <discocaml> <psychokitty> "all this for structural recursion"

10:06 <discocaml> <darrenldl> precisely my thought

10:10 <discocaml> <darrenldl> i tried very hard to understand their perspective from a language with no ADT

10:10 <discocaml> <darrenldl>

10:10 <discocaml> <darrenldl> at the end it felt like a proof exercise about the "equivalence in expressiveness" more than anything else

10:13 <discocaml> <psychokitty> there's some cuteness to the visitor pattern, like you can strategize out various traversal methods, have a default visitor (permitting you to only overload parts you care about traversing), but, all in all, a coping strategy for languages without a true match construct

10:18 <discocaml> <darrenldl> right now i'm entertaining the idea of a static go analyser capable of doing exhaustive "pattern matching" check, at least for a subset of go (plus some annotations maybe)

10:18 <discocaml> <darrenldl> if i have to use go in my career, i want to at least make it less painful

10:19 <discocaml> <psychokitty> my hope is to further avoid using languages I don't like in my career.. have had various success so far

10:20 <discocaml> <darrenldl> depends on where one resides i suppose. FP is definitely not a common theme in australian companies

10:20 <discocaml> <darrenldl> (well rust is sometimes around, in terms of langs having ADT, but rare cases)

10:20 <discocaml> <psychokitty> there's always remote work - I say this, yet, as it stands I've been too anxious to apply to remote work that uses OCaml

10:21 <discocaml> <darrenldl> i made one attempt at such application : v

14:54 <discocaml> <L1st.fold_left> Hey there, I was wondering if there was a way to declare a type with an infix constructor.

14:54 <discocaml> <L1st.fold_left> I know it is possible to do so with operators, and in the List module, 'a list is declared as ` [] | (::) of 'a * 'a list`

14:54 <discocaml> <L1st.fold_left> However, when I try to define a new type, Ocaml denies every infix constructor except (::), which means I would have no choice but to overwrite (::) (Which seems like an awful idea, let's not do that)

14:59 <discocaml> <Kali> (::) is the only one

14:59 <discocaml> <octachron> `(::)` is the only infix constructor.

14:59 <discocaml> <Kali> you could put it into its own module, so that it doesn't override the default

15:01 <discocaml> <L1st.fold_left> Okay :/

15:01 <discocaml> <L1st.fold_left> Oh nice

15:02 <discocaml> <Kali> you could put it into its own module, so that it doesn't override the default (except where you want it to)

15:45 <discocaml> <deepspacejohn> Yes, there's nothing wrong with overriding `::` with your own definition. This is pretty useful to define custom list types (i.e. heterogeneous lists, non-empty lists, etc.)

15:50 <discocaml> <deepspacejohn> Of course, namespacing your definition in its own module is a good idea. But it's generally a good idea to separate types into modules anyway (especially if they would shadow existing constructors)