> My date for programmatic formal checking of programs in lisp is the early 70s.
(If not the late 60s.)
Just for the record,
programmatic formal checking of programs in general
and
applying type theory to programming
do have a big intersection,
but neither is a subset of the other, of course.
And then functional programming offers quite a bit more that is valuable than type checking and type inference (again of course).
[#Lisp and type theory]
> type theory- it's not really different to what lisp was doing approximately a century ago
That is too imprecise.
Lisp started off _untyped_ lambda calculus less than 3/4 of a century ago.
Lisp did beget functional programming a little later, but the real application of type theory in computer programming started with the ML family of languages and Haskell.
(Maybe I missed one more language.)
React-like functional webcomponents, but with vanilla HTML, JS and CSS
Introducing Dim – a new #Framework that brings #ReactJS-like functional #JSX-syntax with #VanillaJS. Check it out here:
Project: https://github.com/positive-intentions/dim Website: https://dim.positive-intentions.com
My journey with #WebComponents started with Lit, and while I appreciated its native browser support (less #Tooling!), coming from #ReactJS, the class components felt like a step backward. The #FunctionalProgramming approach in React significantly improved my #DeveloperExperience and debugging flow.
So, I set out to build a thin, functional wrapper around #Lit, and Dim is the result! It's a #ProofOfConcept right now, with "main" #Hooks similar to React, plus some custom ones like useStore for #EncryptionAtRest. (Note: #StateManagement for encryption-at-rest is still unstable and currently uses a hardcoded password while I explore #Passwordless options like #WebAuthn/#Passkeys).
You can dive deeper into the #Documentation and see how it works here:
Dim Docs: https://positive-intentions.com/docs/category/dim
This #OpenSource project is still in its early stages and very #Unstable, so expect #BreakingChanges. I've already received valuable #Feedback on some functions regarding #Security, and I'm actively investigating those. I'm genuinely open to all feedback as I continue to develop it!
Learn physics with functional programming. ~ Esteban Marin. https://youtu.be/Zp5D_wMi97Q #Haskell #FunctionalProgramming #Physics
#ReleaseWednesday — Extracted & extended the LISP-like DSL from an existing #ThingUmbrella example[1] as new small package for better/direct re-use in other projects:
The core language is kept intentionally minimal, aimed at simple sandboxed data transformations/derivations, small code snippets/expressions in GUIs or config settings. However, the language is very easy to extend/customize with new functions or control flow constructs etc. Currently, the language is interpreted and has the following builtins (see screenshots). There's no macro support so far (and not sure if that's even desired here)...
[1] The original #HowToThing example browser REPL this was extracted from (and which has now been updated to use the new package):
https://demo.thi.ng/umbrella/lispy-repl/
#ThingUmbrella #Lisp #DSL #FunctionalProgramming #REPL
#programming #gamedev #devlog #commonLisp #series #lazyEvaluation #functionalprogramming https://screwlisp.small-web.org/lispgames/cl-series-for-game-logic/ #lispgamejam
Since cl-series generates native common lisp code by working at macro expansion time, I consider it suitable for my software individuals (who want only clos-less common lisp and their own logic (which they have an introspective theory of).
In particular, I use series to cut out rectangular subsequence of sequences -s
SERIES DOC UPDATE FROM RTOY https://gitlab.common-lisp.net/rtoy/cl-series/-/wikis/Series-User's-Guide
This took me three months (a month longer than I had hoped), but I finally have merged it into the main branch!
This patch rewrites the Emacs Lisp lexer and parser in Scheme using Scheme code that is 100% compliant with the #R7RS standard, so it should now work across all compliant Scheme implementations. Previously the old parser relied on #Guile -specific regular expressions.
This patch also implements a new feature where a stack trace is printed when an error occurs. This of course makes debugging much, much easier. Previously the old parser did not keep track of where code evaluation was happening, it simply produced lists without source location information. The new parser constructs an abstract syntax tree (AST) and source locations are attached to the branches of the tree which can be used in error reporting and stack traces.
Next I will make whatever minor tweaks might be necessary to get my Emacs Lisp interpreter run on other Scheme implementations, in particular MIT Scheme, Gambit, Stklos, and Gauche. I would also like to try to get it running on Chicken and Chez, although these are going to be a bit more tricky.
Then I will continue with the task of implementing a new declarative GUI library.
Andy is convinced that functional programming isn’t boring. Listen to find out if he’s right!
Added a new convenience transducer for clipping and binning values, e.g. as preparation step for histogram generation whilst working in the REPL. New release forthcoming. A small code example attached (actually taken from the doc string of the new `binned()` transducer).
Ready to geek out over functional programming? Join us for the upcoming FPIndia Bangalore meetup!
https://hasgeek.com/fpindia/bangalore-fp-april-meetup/
#Bangalore #FunctionalProgramming #FPIndia #Meetup #India #Haskell #PureScript #OCaml #Elixir #Clojure #Scala
The calculated typer. ~ Zac Garby, Patrick Bahr, Graham Hutton. https://bahr.io/pubs/files/calctyper-paper.pdf #Haskell #FunctionalProgramming
I am once again faced with the bleak irony of people who like to code in the terminal with Vim or Nano, but also install onto their computer some 5 or 10 apps via FlatPak or Docker, including VSCode, each installed with their own entire copies of Node.js and Electron.js (differing only in their minor revision number), while also complaining about Emacs being “bloated” because it ships with a miniature web browser and fully-featured e-mail client.
@xameer the “R7RS small” Scheme standard has a full numerical tower built-in, including unbounded integers.
《ミ》λ≡ 
(- (+ (expt 10 100) 1) (expt 10 100))gives you precisely the correct answer without any floating-point operations. Although macros for symbolic computation with optimization that would avoid computation of (expr 10 100) is “an exercise left to the reader.” Haskell might do the optimal computation though thanks to it’s lazy evaluation.
Why dont we define uncertainty as a function of time ?
Isnt a function also a variable ?
Aha
> In functional programs the variables are like those in mathematics, once a value has been assigned the value cannot change.
In imperative languages it is typical that the values held by variables an be changed.
/Higher-order
/Random
#functionalprogramming
Sharing my scrappy fiddles after deciding to pick up this project that had a 2 year hiatus.
https://github.com/thgs/functional
Any comments, issues, discussions or even code is welcome.
As much as I love Star Trek, every time I hear one of the characters say they want to maybe try using a “recursive algorithm“ to solve some sci-fi problem, like reconstructing a damaged database or decrypting some super-secret alien message, or reinitializing a whole bunch of warp thingies in just the right sequence or whatever, I physically cringe every single time.
the most common copy of "a new implementation technique for applicative languages" by D. A. Turner is this pdf where the first page is corrupted and just cuts off after the 2nd line (see attached pic) ... the interesting thing is that this paper was OCRd before the file corruption occurred, so all the text is still there if you highlight it (see 2nd attached pic)
In today's cringe
An article on medium titled:
"Why #functionalprogramming Languages Will Never Be Mainstream"
To save you a click, the top reason is
"Writing a loop is a lot harder."
excerpt:
"To write loops without recursion in a functional programming language, you have to master about *50* higher level functions. Compare that to most other languages where you only have to master 2 or 3 language constructs (for, while, foreach) to write a loop."
