Functional programming jargon in plain English

Post by 8note » Mon, Jul 04, 2022, 7:56 PM UTC

saithound wrote: post #54

goto11 wrote: post #36

Pet peeve: The word "just" when used to gloss over something with the author don't know how to explain. Using "just" shift the burden from the author to the reader, since it signals it is the readers fault if they don't understand. > A homomorphism is just a structure preserving map. In fact, a functor is just a homomorphism between categories as it preserves the original category's structure under the mapping. How a…

Mathematicians use "just" with a specific meaning: it is not used to gloss over something that the author doesn't know how to explain. It has a purpose, useful for mathematically trained readers. For suc a reader, "a homomorphism is just a structure preserving map" makes it clear that "homomorphism" and "structure-preserving map" can be used interchangably, and that by understanding one of the concepts, you'll immedi…

Post by lgas » Mon, Jul 04, 2022, 8:11 PM UTC

skybrian wrote: post #121

jerf wrote: post #97

Earlier quoted context omitted.

I'm not trying to dodge your question, but the answer to your question is that until you work with it for a while you're not going to understand it. Any blog-sized, bite-sized snippet isn't impressive. You have to work with it for a while. I speak many computer languages, and one of the ways I measure them is, "what do I miss from X when using Y?" The answers will often surprise you; the thing you'd swear up and down…

That's an example of why Haskell code is often hard to read, and why I'm glad this isn't available in other languages. Why not write out the callback given to map using a let block? Then you can give meaningful names to intermediate values so it's easier to see how the pipeline works. (Though, functional programmers would probably pass up the opportunity and use one-letter variable names.)

    let f = makeMap x y
    in map someFunc . filter other . map f $ userList

    let mapOfXy = makeMap x y
    in map someFunc . filter other . map mapOfXy $ userList

Post by a1369209993 » Mon, Jul 04, 2022, 8:36 PM UTC

chowells wrote: post #146

a1369209993 wrote: post #142

Earlier quoted context omitted.

> Note: not execution model. That needs a bit more. Actually... not really? You need the foreign function interface to have anything useful to execute, but (unless you're talking about something else?) the execution model is basically just a State monad carrying a unique magic token, built on top of the same evaluation model as everything else.

The execution model needs something that actually drives execution. There needs to be something that explains how IO actions are actually run. The state approach kind of works until you need to explain multiple threads, then it falls over. Edward Kmett did some work to describe IO as an external interpreter working through a free monad. That approach provides very neat semantics that include multiple threads and FFI…

Post by anewpersonality » Mon, Jul 04, 2022, 8:58 PM UTC

Post by lgas » Mon, Jul 04, 2022, 9:04 PM UTC

lgas wrote: post #158

dllthomas wrote: post #156

Earlier quoted context omitted.

One obvious place to look is things that are almost a monad but can't be lawful and which might nonetheless be useful. An example that comes to mind is trying to use Set as a monad (for nondeterminism like the list monad, but with deduplication), which you can't do for some potentially avoidable technical reasons (it would have to be restricted to things you can Ord) but more importantly Set can't be a monad because…

I thought it was the case that you can't implement the Monad type class using the built in Data.Set implementation of Sets but there's no reason in principle why you couldn't build a Set Monad that works that way, right? Perhaps I am mistaken so I will investigate further.