danidiaz

11 ms·

91.
by danidiaz 8y ago
Looks like this kind of competition is beneficial to society—to the point of granting a new lease of life to gravely ill people—and should be encouraged.
92.
by danidiaz 8y ago
The laws are important though. They ensure that the "statement-like" things we build out of expressions do behave like statements. For example, it would be weird if we had three statements A B C that wrote to console, and sequenci
93.
by danidiaz 8y ago
Even if duplicate expressions are optimized by the engine, they hurt the readability and maintainability of the query, especially if they are big and complex.
94.
by danidiaz 8y ago
LATERAL joins can help with reusing calculations https://www.periscopedata.com/blog/reuse-calculations-in-the...
95.
by danidiaz 8y ago
Another good talk about using types to guide your programming—instead of merely checking it for errors—is "Is a type a lifebuoy or a lamp?" by Conor McBride https://skillsmatter.com/skillscasts/8893-is-a-type-
96.
by danidiaz 8y ago
I'm reminded of Gerard O'Neill's seventies vision of space habitats https://99percentinvisible.org/episode/home-on-lagrange/ The artistic depictions tend to have a "suburb in a bottle" fee
97.
by danidiaz 8y ago
If the project had no existing dependent types at all, couldn't you just perform a runtime check before calling the library? The check would return evidence that [i: i%2 == 0] for the particular i, or fail at runtime. If it succeeded,
98.
by danidiaz 8y ago
> the ugly downsides of dependent types and how to avoid them There's this Reddit answer from two years ago, and the subsequent comments https://www.reddit.com/r/haskell/comments/3zc81v/tradeoffs_
99.
by danidiaz 8y ago
In the Idris language, one best practice is to relegate to the outer shell not only IO effects, but also "partiality"—in the sense of computations that might enter an unproductive infinite loop. (In Haskell, one way of getting int
100.
by danidiaz 8y ago
There's also a Haskell writen in Lisp (in Racket, to be exact) https://www.youtube.com/watch?v=g6UCeHiKodo
101.
by danidiaz 8y ago
Types that represent producers of data often return a special result value at the end, of a type different from the values that are yielded. Say, a stream of integers that return a Boolean when it's exhausted. By choosing an unhabited
102.
by danidiaz 8y ago
> The essence of monad is thus separation of composition timeline from the composed computation's execution timeline I also feel that it makes sense. Haskell prefers expressions to statements. When needed, statement-like things are
103.
by danidiaz 8y ago
Some linear type systems garantee that functions defined in them have polynomial time complexity: http://www.cs.cmu.edu/~fp/courses/15816-s12/misc/hofmann03ic... http://www.kurims.kyoto-u.ac.j
104.
by danidiaz 8y ago
Strictly speaking, one doesn't even need a plugin to use ack, ag or ripgrep from Vim. It is enough to set the "grepprg" option (perhaps also "grepformat") and then one can invoke the built-in ":grep" comma
105.
by danidiaz 8y ago
I use the default package functionality of Vim 8.x (see :h package). I create a ".vim\pack\foo\start\" folder and git clone plugins there. Invoking ":helptags .vim\pack\foo\start\somenewplugin\docs" for a plugin makes th
106.
by danidiaz 8y ago
: is used for type annotations instead of :: like in Haskell. The double asterisk is syntactic sugar for a "dependent pair" http://docs.idris-lang.org/en/latest/tutorial/typesfuns.html... Basically,
107.
by danidiaz 8y ago
The Ottoman History Podcast is consistently interesting: https://soundcloud.com/ottoman-history-podcast/tracks
108.
by danidiaz 8y ago
In his talk about "milestones in the development of lazy, strongly typed, polymorphic, higher order, purely functional languages" David Turner mentions that the wan't adverse to SASL ( https://youtu.be/QVwm9jlB
109.
by danidiaz 8y ago
Reminds me of "project Milo" from back in 2009 https://en.wikipedia.org/wiki/Project_Milo https://www.youtube.com/watch?v=CPIbGnBQcJY
110.
by danidiaz 8y ago
Ah I see. Events form a Monoid, so I guess I could have a "something happens" event aggregating all the sensor updates, and sample the "inverterPowerChange" Behaviour at the occurrences of the Event. The API for reactive
111.
by danidiaz 8y ago
The reactive-banana code does more things; it also does the equivalent (in Observer pattern terms) of adding observers to the corresponding observables.
112.
by danidiaz 8y ago
I have a small quibble about the names though—or perhaps I didn't fully understand the example. Since "inverterPowerChange" returns a Behaviour http://hackage.haskell.org/package/reactive-banana-1.2.0.0&#
113.
by danidiaz 8y ago
A science-fiction novel in which food is central to the plot is "Alastor: Wyst" by Jack Vance. The characters are bored by the tasteless food they usually have to eat ("Some gruff and deedle, with some wobbly to fill the crac
114.
by danidiaz 9y ago
Old problem. The book "Too Much to Know" by Ann Blair is about how intellectuals dealt with information overload in early modern Europe: https://yalebooks.yale.edu/book/9780300165395/too-much-know
115.
by danidiaz 9y ago
Looks like the plot of "A for Andromeda" https://en.wikipedia.org/wiki/A_for_Andromeda
116.
by danidiaz 9y ago
How about "cacopattern"? https://en.wiktionary.org/wiki/Category:English_words_prefix...
117.
by danidiaz 9y ago
The streams/sinks work in the IO monad and that induces an ordering of the effects, yes. Within the callback, you can still do things like filtering or taking only a part of the stream. Returning the stream itself from the "withFi
118.
by danidiaz 9y ago
One possible solution is to take a "beautiful fold" http://hackage.haskell.org/package/foldl-1.3.7/docs/Control-... and connect it to an effectful stream of bytes http://hackage.haskell.o
119.
by danidiaz 9y ago
Collectors in Java >= 8 are quite reminiscent of these "beautiful folds", so much that I have wondered why the standard library lacks a proper Applicative-like composition method, which is so useful for avoiding multiple traver
120.
by danidiaz 9y ago
The talk "APLicative Programming with Naperian Functors" shows an approach to APL-like programming in Haskell https://www.youtube.com/watch?v=D1sT0xNrHIQ Many APL idioms, when translated to Haskell, are related to

More ›