Proctor

Announcing FPCasts.com! Let's help build a place to find podcasts covering Functional Programming fpcasts.com

@bradmeltzer When can we expect “I Am @levarburton”??? 🙏🥺

@marick Followed!

Proof. He signed my King Size T-shirt super hero quilt with his “Ordinary People Change The World” and his book tour shits on it.

@jessysaurusrex Is there a good place to follow you on other sites in case?

Them: But maybe the grass _is_ greener on the other side? Me: Oh, that would be _just great_. 🙄 Just what I need _more_ allergies.

There is no blue, only azul.

@marick . @ShriramKMurthi might have good perspective being a LISPer and in the Verification Systems side which is even stronger than the Haskell/ML type systems (e.g. think Agda and Coq), along with the directions they are taking in Pyret for dynamic ML types

Re. retros. Why do you need a format? Just have a conversation. Why do you need a retro, for that matter? Just have lots of conversations as issues come up. The key concept is *continuous* improvement, not improvement every two weeks in some meeting. 1/3

@khinsen @fngeekery @PyretLang You don't *have* to run it in the browser! pyret.org/set-sail/ says how to run it from a desktop. @joepolitz can probably say more.

@ShriramKMurthi @samth @HoustonFPUG Thanks!!!

@ShriramKMurthi @samth @HoustonFPUG But will definitely be downloading that paper to give it a good read.

@ShriramKMurthi Based off your history with dynamic languages and static types/verification, is there something that demonstrates a "left fold of apply/comp over a list of functions" in the static typing realm? e.g. (foldl (lambda (accum f) (apply f accum)) x '(k j i h g f))

@ShriramKMurthi @samth Yeah, not true magic, but was more in the sense of I can wave my hand and say "it works" without having to prove it. The more "magic" over science/engineering/math side ;)

@stevenproctor @samth Put differently, your situation is not dynamic enough to "beat" a sophisticated enough type system – it's only *annoying* enough to make it painful and make you retreat (-:.

@ShriramKMurthi @samth The question stemmed from showing off the Interceptor pattern in Clojure, where it is a context map that gets threaded through a procesing pipeline where keys get added. Being in the Static Type world, they were curious about ensuring type safety by keys being present

@stevenproctor @samth You didn't specify that initially! Yeah, you can't do that directly. You can encode it using an algebraic datatype but you'd have to inject/project.

@ShriramKMurthi @samth And it may be that the part where the accum has the potential to changes its type on every "reduction" may be something that lives in the realm of dynamic type "magic"

@ShriramKMurthi @samth I think so, it looks like a good starting point to chew on. I think we were also wondering in the case where the apply, or compose, might change the type of the accumulated value at each step. e.g. f: b -> c g: a -> b (foldl comp [f g]) : a -> c

@ShriramKMurthi Also, the `f` `g` and the like were symbols mapped to function names. I was translating from Clojure into a Scheme/Racket style but likely messed up the function names as symbols for passing functions around

@ShriramKMurthi Was pointing out the idea of the foldl of apply in the Lisp/dynamic world to those in static typing world, and we were wondering how it would translate. Not sure if you know of anything as reference since your heart is in both worlds of dynamic Lisp and Verification. 😉