Newest at the top
| 2025-03-29 12:16:17 +0100 | ensyde | (~ensyde@2601:5c6:c200:6dc0::6f7f) (Quit: WeeChat 4.6.0) |
| 2025-03-29 12:15:44 +0100 | merijn | (~merijn@host-vr.cgnat-g.v4.dfn.nl) merijn |
| 2025-03-29 12:08:53 +0100 | aforemny_ | (~aforemny@i577B132D.versanet.de) (Ping timeout: 244 seconds) |
| 2025-03-29 12:05:07 +0100 | caconym | (~caconym@user/caconym) caconym |
| 2025-03-29 12:04:40 +0100 | merijn | (~merijn@host-vr.cgnat-g.v4.dfn.nl) (Ping timeout: 268 seconds) |
| 2025-03-29 12:04:04 +0100 | __monty__ | (~toonn@user/toonn) toonn |
| 2025-03-29 12:00:04 +0100 | caconym | (~caconym@user/caconym) (Quit: bye) |
| 2025-03-29 11:58:33 +0100 | lxsameer | (~lxsameer@Serene/lxsameer) (Ping timeout: 244 seconds) |
| 2025-03-29 11:58:26 +0100 | <Leary> | Anything built from base types with sums and products counts as a tree in my book, some of them are just really wide or stunted. ¯\_(ツ)_/¯ |
| 2025-03-29 11:58:24 +0100 | sand-witch | (~m-mzmz6l@vmi833741.contaboserver.net) |
| 2025-03-29 11:57:41 +0100 | merijn | (~merijn@host-vr.cgnat-g.v4.dfn.nl) merijn |
| 2025-03-29 11:57:35 +0100 | sand-witch | (~m-mzmz6l@vmi833741.contaboserver.net) (Remote host closed the connection) |
| 2025-03-29 11:53:06 +0100 | <tomsmeding> | (in a language with zeroth-order arrays, 'map' on arrays is a second-order function) |
| 2025-03-29 11:52:44 +0100 | ljdarj | (~Thunderbi@user/ljdarj) ljdarj |
| 2025-03-29 11:52:38 +0100 | <tomsmeding> | I think I'll just go with "zeroth-order"; I even have a sensible use for "second-order", i.e. functions that take functions that don't take functions |
| 2025-03-29 11:52:04 +0100 | <tomsmeding> | it's a good unorthodox suggestion, but I'm not a fan either |
| 2025-03-29 11:51:37 +0100 | <tomsmeding> | Leary: then arrays and sum types would need to be trees, and function types not |
| 2025-03-29 11:47:39 +0100 | <Leary> | tomsmeding: Trees? |
| 2025-03-29 11:46:38 +0100 | merijn | (~merijn@host-vr.cgnat-g.v4.dfn.nl) (Ping timeout: 245 seconds) |
| 2025-03-29 11:42:53 +0100 | jacopovalanzano | (~jacopoval@cpc151911-cove17-2-0-cust105.3-1.cable.virginm.net) |
| 2025-03-29 11:41:55 +0100 | merijn | (~merijn@host-vr.cgnat-g.v4.dfn.nl) merijn |
| 2025-03-29 11:38:53 +0100 | <tomsmeding> | this is not in haskell specifically, but I'm asking here because it's somewhat related :) |
| 2025-03-29 11:38:30 +0100 | <tomsmeding> | even sum types are messy but only to a limited extent |
| 2025-03-29 11:38:15 +0100 | <tomsmeding> | The context here is an array language: I want to allow arrays of zeroth-order types only, because functions have closures and everything becomes messy then |
| 2025-03-29 11:37:39 +0100 | <tomsmeding> | yes, (Int, Int -> Int) would be a type that contains function arrows, and would thus not be allowed for my thingy types |
| 2025-03-29 11:36:42 +0100 | <haskellbridge> | <Liamzee> I'm guessing it's just that in languages where functions are values the term is more confused |
| 2025-03-29 11:36:26 +0100 | <haskellbridge> | <Liamzee> so would (Int, Int -> Int) be a type that contains function arrows? |
| 2025-03-29 11:36:08 +0100 | merijn | (~merijn@host-vr.cgnat-g.v4.dfn.nl) (Ping timeout: 252 seconds) |
| 2025-03-29 11:33:41 +0100 | tromp | (~textual@2001:1c00:3487:1b00:9865:6ec1:d353:2dc8) |
| 2025-03-29 11:33:34 +0100 | <tomsmeding> | but I'm not sure I've seen "zeroth-order type" before, and it's also a bit of an awkward phrase |
| 2025-03-29 11:33:10 +0100 | <tomsmeding> | then the thing I'm looking for would be type with order 0 |
| 2025-03-29 11:32:57 +0100 | <tomsmeding> | if you define Order[Int] = 0; Order[(a, b)] = max(Order[a], Order[b]); Order[a -> b] = max{1 + Order[a], Order[b]}, then a first-order function is a function with type of order 1, and a higher-order function is a function with type of order >1 |
| 2025-03-29 11:32:16 +0100 | <tomsmeding> | a higher-order function is a function that takes functions; a first-order function is a function that does not |
| 2025-03-29 11:32:05 +0100 | <tomsmeding> | one can generalise from https://en.wikipedia.org/wiki/Higher-order_function |
| 2025-03-29 11:30:11 +0100 | <tomsmeding> | well, (Int, Int -> Int) is also a non-function type, in my mind |
| 2025-03-29 11:26:17 +0100 | lxsameer | (~lxsameer@Serene/lxsameer) lxsameer |
| 2025-03-29 11:24:34 +0100 | Sgeo | (~Sgeo@user/sgeo) (Read error: Connection reset by peer) |
| 2025-03-29 11:20:30 +0100 | j1n37 | (~j1n37@user/j1n37) j1n37 |
| 2025-03-29 11:16:53 +0100 | j1n37 | (~j1n37@user/j1n37) (Read error: Connection reset by peer) |
| 2025-03-29 11:16:34 +0100 | <haskellbridge> | <Liamzee> non-function types? |
| 2025-03-29 11:15:56 +0100 | j1n37 | (~j1n37@user/j1n37) j1n37 |
| 2025-03-29 11:15:30 +0100 | j1n37- | (~j1n37@user/j1n37) (Read error: Connection reset by peer) |
| 2025-03-29 11:14:53 +0100 | <tomsmeding> | but if there's a good term for such types where you do consider Foo to be "simple", I'm also open to those |
| 2025-03-29 11:14:44 +0100 | ljdarj | (~Thunderbi@user/ljdarj) (Ping timeout: 260 seconds) |
| 2025-03-29 11:14:15 +0100 | <tomsmeding> | Liamzee: It's a fair point. I think I'd want Foo to "contain function arrows", i.e. to _not_ be in the category that I want a name for |
| 2025-03-29 11:10:31 +0100 | sprotte24 | (~sprotte24@p200300d16f18ca00810b5da35042238f.dip0.t-ipconnect.de) |
| 2025-03-29 11:00:33 +0100 | <haskellbridge> | <Liamzee> Foo doesn't contain any function arrows, but it's a newtype over a function type |
| 2025-03-29 11:00:17 +0100 | <haskellbridge> | <Liamzee> newtype Foo = MkFoo (Int -> Char) |
| 2025-03-29 11:00:06 +0100 | <haskellbridge> | <Liamzee> meaningful |
| 2025-03-29 11:00:03 +0100 | <haskellbridge> | <Liamzee> erm, that's the wrong word |