02:50 <myrkraverk> What is a good way to trim punctuation from words? I have a simple word counter, which reads lines and splits them on spaces, but then I have punctuation in my words.

02:51 <myrkraverk> I used String.split_on_char to split the lines.

03:28 <discocaml> <deepspacejohn> The simplest would probably be to use String.iter and write the characters to a buffer, and skip the punctuation characters you don’t want to keep. (That’s assuming that you only want to remove ASCII punctuation.)

03:35 <myrkraverk> For my exercise, I'm limiting the input to ASCII, so that works.

03:36 <myrkraverk> As an exercise, I tried the following in the REPL, but it seems to return the function, not execute the last stage.

03:36 <myrkraverk> let f ( c ) = let l = Char.lowercase_ascii c in let k = Char.code l in Char.code 'a' >= k && Char.code 'z' <= k in Seq.filter f ( String.to_seq ".aoeu//" ) ;;

03:36 <myrkraverk> Is there a way to fix that?

03:38 <myrkraverk> While I'm sure there are better ways to do this; I just wanted to exercise with hand written code first.

03:49 <myrkraverk> Ah, I was just missing the String.of_seq in the final stage.

03:49 <myrkraverk> let f ( c ) = let l = Char.lowercase_ascii c in let k = Char.code l in Char.code 'a' <= k && Char.code 'z' >= k in String.of_seq( Seq.filter f ( String.to_seq ".aoeu//" ) ) ;;

03:49 <myrkraverk> works fine.

04:13 <discocaml> <darrenldl> reads like you're building a pipeline, in which case you might enjoy the pipeline operator: String.to_seq ".aoeu//" |> Seq.filter f |> String.of_seq

04:14 <discocaml> <darrenldl> let f c = ... is also more common than let f ( c )

04:14 <myrkraverk> I'll keep that in mind.

04:45 <discocaml> <froyo> for the filtering function`let f c = ...`, you could have just `function 'a'..'z' | 'A'..'Z' -> true | _ -> false`

04:46 <discocaml> <froyo> i.e. `String.to_seq ".aoeu//" |> Seq.filter (function ...) |> String.of_seq`

04:53 <myrkraverk> I turned it into filter_map to downcase at the same time.

04:54 <myrkraverk> And now I have a semi-useful word counter I can throw at ASCII text files.

10:42 <discocaml> <_4ad> hi, opam upgrade fails with this: http://okturing.com/src/20078/body. I am on macOS/arm64.

10:44 <discocaml> <_4ad> I can obliterate `.opam` and reinstall, but these sort of problems happen for me every couple of months. it's just macOS with homebrew and opam installed from homebrew. I do nothing more advanced than `opam update && opam upgrade`.

11:23 <discocaml> <_4ad> ok, with help from `#opam` I fixed it. the `patch(1)` has to be GNU patch, so if you have homebrew after the system utilities, it won't work.

11:23 <discocaml> <_4ad> if you want to keep homebrew after the system utilities, this works: `ln -s /opt/homebrew/bin/patch $HOME/bin/gpatch` then `rm -rf $HOME/.opam/repo/default{,.tar.gz} && opam update default`, assuming `$HOME/bin` is in your `PATH`.

20:00 <discocaml> <froyo> why is `Uchar.hash` just its int value? Shouldn't it be actually hashed like `Int.hash` and `Char.hash`?

20:01 <discocaml> <yawaramin> which library? Jane Street?

20:01 <discocaml> <froyo> stdlib.

20:05 <companion_cube> Sadly the stdlib is really lacking when it comes to hashing

20:06 <discocaml> <yawaramin> can someone explain why it matters that it's just the integer value of the uchar? if it's 1:1 mapping, it doesn't matter, does it?

20:07 <discocaml> <froyo> why not extend that argument to `Bool.hash` which does actual hashing then

20:08 <companion_cube> It matters because it's not a good random distribution

20:11 <discocaml> <yawaramin> interesting. the person who suggested it didn't justify why, i guess they weren't thinking about the distribution https://github.com/ocaml/ocaml/pull/80#discussion_r14857426

20:15 <companion_cube> It's a bit weird that our only global story for hashing is, really, the polymorphic hash

20:18 <discocaml> <yawaramin> is it? it's the same global story for a lot of generic things

20:18 <discocaml> <yawaramin> is it? it's the same global story for a lot of generic things in OCaml

20:19 <discocaml> <froyo> companion_cube, you get a seed and you get to control how far it traverses your structure, it's alright tbh :P

20:31 <companion_cube> I mean yeah, we lack a good story for typeclasses, nothing new there

20:31 <companion_cube> but with equality the stdlib functions are good

20:31 <companion_cube> with hashing it's a mixed bag :/

20:37 <discocaml> <yawaramin> actually are we locked in to this decision in Uchar? couldn't we just change it to use `Hashtbl.hash`?

20:38 <discocaml> <froyo> Hashtbl.hash would introduce a dependency. same with to_int |> Int.hash

20:50 <companion_cube> we should honestly have a Hash module

20:50 <companion_cube> and a few intrinsics for hashing primitive types

20:50 <companion_cube> and combining hashes/carrying a hash context around

21:13 <discocaml> <froyo> hashing combinators huh... name it Hsh!

21:13 <discocaml> <froyo> (like Fmt)

21:18 <companion_cube> yikes :p

21:18 <companion_cube> I call it CCHash but it'd be nice if the runtime provided a few (fast) combinators

21:19 <companion_cube> stuff that takes a int64 and some type t (int, string, etc.) and mixes the type into the int64

21:19 <discocaml> <froyo> I've seen a `mix` primitive idea thrown here and there in the issue tracker