Logs: liberachat/#haskell
| 2021-07-29 16:55:35 | × | motle quits (~motle@cpc103048-sgyl39-2-0-cust506.18-2.cable.virginm.net) (Quit: Connection closed) |
| 2021-07-29 16:57:13 | → | burnsidesLlama joins (~burnsides@dhcp168-019.wadham.ox.ac.uk) |
| 2021-07-29 16:57:35 | × | burnsidesLlama quits (~burnsides@dhcp168-019.wadham.ox.ac.uk) (Remote host closed the connection) |
| 2021-07-29 16:57:42 | → | burnsidesLlama joins (~burnsides@dhcp168-019.wadham.ox.ac.uk) |
| 2021-07-29 16:58:32 | × | burnsidesLlama quits (~burnsides@dhcp168-019.wadham.ox.ac.uk) (Remote host closed the connection) |
| 2021-07-29 16:58:58 | → | burnsidesLlama joins (~burnsides@dhcp168-019.wadham.ox.ac.uk) |
| 2021-07-29 16:59:59 | → | lavaman joins (~lavaman@98.38.249.169) |
| 2021-07-29 17:00:14 | → | deejaytee joins (~deejaytee@cpc91196-cmbg18-2-0-cust215.5-4.cable.virginm.net) |
| 2021-07-29 17:00:21 | × | chomwitt quits (~chomwitt@athedsl-32041.home.otenet.gr) (Ping timeout: 258 seconds) |
| 2021-07-29 17:01:01 | → | econo joins (uid147250@user/econo) |
| 2021-07-29 17:02:34 | × | fossdd quits (~fossdd@sourcehut/user/fossdd) (Ping timeout: 240 seconds) |
| 2021-07-29 17:03:25 | → | fossdd joins (~fossdd@sourcehut/user/fossdd) |
| 2021-07-29 17:03:42 | × | burnsidesLlama quits (~burnsides@dhcp168-019.wadham.ox.ac.uk) (Ping timeout: 265 seconds) |
| 2021-07-29 17:04:43 | × | fluffyballoon quits (~fluffybal@pat-verona-h.epic.com) (Quit: Client closed) |
| 2021-07-29 17:04:52 | <lechner> | Hi, why does readCreateProcessWithExitCode returns stdout as a String, please? It is the same as [Char], which according to Data.Char are Unicode code points. What if the called program, like all programs, outputs a ByteString that may or may not be UTF-8? Does System.Process attempt to decode? Thanks! |
| 2021-07-29 17:05:05 | → | fluffyballoon joins (~fluffybal@pat-verona-h.epic.com) |
| 2021-07-29 17:07:41 | → | motle joins (~motle@cpc103048-sgyl39-2-0-cust506.18-2.cable.virginm.net) |
| 2021-07-29 17:08:48 | <motle> | i spent half of last year designing asyncronous scheduling on graph distrbuted computing for these trading robot things! like, years wasted if the only reason is scanners! |
| 2021-07-29 17:09:56 | <motle> | had restricted types flowing on the edges of a hierarchical tensor net, was mental |
| 2021-07-29 17:10:45 | <motle> | damn AWS sentinals killing the haskell apps |
| 2021-07-29 17:11:25 | <motle> | all that just for a persistent net of processes that could start each other up if the sentinal got one of 'em |
| 2021-07-29 17:12:33 | <motle> | so yeah - to make something of that, i kind of want to get a programming language at least |
| 2021-07-29 17:12:44 | <motle> | its got graphs too... |
| 2021-07-29 17:12:50 | <motle> | like how we have lists |
| 2021-07-29 17:12:58 | <motle> | and something convolutional |
| 2021-07-29 17:13:11 | → | burnsidesLlama joins (~burnsides@dhcp168-019.wadham.ox.ac.uk) |
| 2021-07-29 17:13:17 | <motle> | extends lenses to pointers? |
| 2021-07-29 17:13:44 | <motle> | anyway, the point is about call by use and lazy evaluation i guess |
| 2021-07-29 17:14:01 | <motle> | running the program starting information flowing over the edges |
| 2021-07-29 17:14:14 | <motle> | so the pointers setting about foraging for nearby data |
| 2021-07-29 17:14:39 | <motle> | i guess then you have an elaboration over everything being just tail calls |
| 2021-07-29 17:14:55 | <motle> | ie there is other stuff "nearby" in different ways in a graph |
| 2021-07-29 17:14:59 | <motle> | than just the tail |
| 2021-07-29 17:15:18 | <motle> | so instead of pattern matching cons being the bare currency of the language... |
| 2021-07-29 17:15:28 | <motle> | and basically traversals and folds being king |
| 2021-07-29 17:15:38 | <motle> | so by suspending traversals on graphs with pointer navigation |
| 2021-07-29 17:15:54 | <motle> | idk... something complicated |
| 2021-07-29 17:16:10 | <motle> | supposed to be the key part to the heart of the language, i cant get it |
| 2021-07-29 17:16:59 | <motle> | anyway, instead of records and complicated lenses via template haskell, everything is done by pointer indexing |
| 2021-07-29 17:17:09 | <motle> | some algebra on the index |
| 2021-07-29 17:17:27 | <motle> | cant quite get the class system, but anyway... |
| 2021-07-29 17:18:10 | × | fossdd quits (~fossdd@sourcehut/user/fossdd) (Ping timeout: 240 seconds) |
| 2021-07-29 17:18:17 | → | Null_A joins (~null_a@2601:645:8700:2290:44f7:81a6:341:7abe) |
| 2021-07-29 17:18:22 | → | Guest9 joins (~Guest9@103.240.170.208) |
| 2021-07-29 17:18:23 | → | fossdd joins (~fossdd@sourcehut/user/fossdd) |
| 2021-07-29 17:18:26 | <motle> | i guess normally "positions" are infact let bound variables, probably enough for now |
| 2021-07-29 17:18:31 | → | doyougnu joins (~user@c-73-25-202-122.hsd1.or.comcast.net) |
| 2021-07-29 17:19:23 | <motle> | i guess thats just an artefact of having put edges where there were function arguments |
| 2021-07-29 17:20:06 | <motle> | its anoying how it basically just allows recursive programs to be expressed and haskell just does that anyway... |
| 2021-07-29 17:20:22 | <motle> | i guess it would be nice to wield the IR directly as a nice graph though... |
| 2021-07-29 17:20:59 | <motle> | oh yeah, it was supposed to go in the compiler as like the lowest level after making lists... not sure if would even require a systemF extension |
| 2021-07-29 17:22:21 | <motle> | yeah i guess everythings just done with mad big records at the minute, could make it better? |
| 2021-07-29 17:22:25 | → | pgib joins (~textual@173.38.117.81) |
| 2021-07-29 17:23:47 | <motle> | i dont actually know how term reduction or whatever it is actually happens |
| 2021-07-29 17:24:14 | <motle> | like if having a nice graph scafolding would help, instead of having to keep track of all the record name subsets |
| 2021-07-29 17:25:46 | × | fossdd quits (~fossdd@sourcehut/user/fossdd) (Ping timeout: 240 seconds) |
| 2021-07-29 17:25:46 | <motle> | i guess its not quite the question "why use datatypes at all, just make a big hetrogenous free list", since this handles the added issues about navigation that are introduced |
| 2021-07-29 17:25:59 | <motle> | which is probably why we use names for that |
| 2021-07-29 17:26:18 | → | fossdd joins (~fossdd@sourcehut/user/fossdd) |
| 2021-07-29 17:26:54 | <motle> | idk, maybe by the time its some illegible IR it probably doesnt matter what record naming is used |
| 2021-07-29 17:27:23 | <motle> | the question is about the ability to make use of a coding approach that also dispensed of records at the top level, in the actual language |
| 2021-07-29 17:27:57 | <motle> | you dont need to use the names, you just have to specify the shape which is all done numerically |
| 2021-07-29 17:28:20 | × | geekosaur quits (~geekosaur@xmonad/geekosaur) (Ping timeout: 258 seconds) |
| 2021-07-29 17:28:46 | <motle> | i mean, i use big 3d grids of numbers all the time, so it would be totally infeasable to have anything other than a numeric record |
| 2021-07-29 17:29:21 | <motle> | i guess normally programs are more "structured" in a sense where big datatypes with meaningful constructor names are used |
| 2021-07-29 17:29:54 | <Drew[m]> | I'm struggling to follow all this. Are you still talking about haskell or are you comparing something to haskell? |
| 2021-07-29 17:29:55 | <motle> | ie how we ended up with this tradition of not really supporting big grids as default datatypes |
| 2021-07-29 17:30:10 | <motle> | Drew[m]: its what i have made in haskell |
| 2021-07-29 17:30:21 | <motle> | just a bunch of work traversing free hetrogenous extensible things |
| 2021-07-29 17:30:37 | <motle> | the point is how close it is to a language fundamenta |
| 2021-07-29 17:30:41 | <Clint> | lechner: you might want something like https://hackage.haskell.org/package/process-extras-0.7.4/docs/System-Process-ByteString.html#v:readProcessWithExitCode instead |
| 2021-07-29 17:30:44 | <motle> | to be comparable to the status of list |
| 2021-07-29 17:31:06 | <motle> | and im trying to work out how it would look more well made and built in |
| 2021-07-29 17:31:23 | <motle> | seems like cartesian convolutions is the standard example |
| 2021-07-29 17:31:40 | <motle> | (needs cycles for the cubes) |
| 2021-07-29 17:31:50 | <motle> | graphamagig |
| 2021-07-29 17:32:12 | × | burnsidesLlama quits (~burnsides@dhcp168-019.wadham.ox.ac.uk) (Remote host closed the connection) |
| 2021-07-29 17:33:03 | <motle> | but yeah, i really want shapes more suited to recursive higher order functions, like map |
| 2021-07-29 17:33:28 | <motle> | just to express the program on the graph scafolding and have it evaluate properly with the states all interlocking |
| 2021-07-29 17:33:30 | → | geekosaur joins (~geekosaur@xmonad/geekosaur) |
| 2021-07-29 17:33:38 | → | burnsidesLlama joins (~burnsides@dhcp168-019.wadham.ox.ac.uk) |
| 2021-07-29 17:33:42 | <motle> | er yeah, we have modifiable programs now too, because the states |
| 2021-07-29 17:34:04 | <motle> | ie the program can store a magic number that can change between evaluation |
| 2021-07-29 17:34:57 | → | derelict joins (~derelict@user/derelict) |
| 2021-07-29 17:35:08 | <motle> | so like, lazy lists state unfold, then states all interconected like pipes/conduit, then message passing doing the argument application to the modifiable functions held at the nodes, ie (state function,state value) pairs |
| 2021-07-29 17:35:22 | × | doyougnu quits (~user@c-73-25-202-122.hsd1.or.comcast.net) (Ping timeout: 240 seconds) |
| 2021-07-29 17:35:27 | <motle> | because states all connected together in a graph like state encoding a list somehow |
| 2021-07-29 17:35:56 | <motle> | and scanning states like mapAcuumL traversal, somehow with the states ending up per node!/// |
| 2021-07-29 17:36:18 | <motle> | its about the connectivity of subsequent scans |
| 2021-07-29 17:36:40 | <motle> | theres an algebra of function composition with a rewrite rule similar to map . map |
| 2021-07-29 17:36:42 | × | azeem quits (~azeem@176.201.11.200) (Read error: Connection reset by peer) |
| 2021-07-29 17:37:13 | <motle> | but then not just sequencing them one after the other, because having branching outputs like a scan doing something like unzip |
| 2021-07-29 17:37:13 | → | azeem joins (~azeem@dynamic-adsl-94-34-48-122.clienti.tiscali.it) |
| 2021-07-29 17:37:32 | <motle> | the program sits still while notionally data is fed subsequent values as inputs |
| 2021-07-29 17:37:49 | <motle> | as opposed to the scanner kind of moving along over the list |
| 2021-07-29 17:38:00 | <motle> | during traversal with the carried accumulator |
| 2021-07-29 17:38:47 | <motle> | just to say something like fold unfold fusion rewrite rules composing on a big graph with zip/unzip style branching |
| 2021-07-29 17:39:06 | × | waleee quits (~waleee@2001:9b0:216:8200:d457:9189:7843:1dbd) (Ping timeout: 240 seconds) |
| 2021-07-29 17:39:34 | <motle> | and somehow thats programs on a graph, i guess intrinsically for straming which explains why there all states, and how they then end up modifiable, since they are collectively like a carry traversing over it like a scanner |
| 2021-07-29 17:39:53 | <motle> | it kind of scans over the list but demangles it through the branching program |
All times are in UTC.