#purescript
Great shout out to #PureScript on the #Haskell in production blog.
@dpwiz @haskman as I said, this is stackage. (See haskman's argument about curation). If you squat, you get kicked.
But yeah, #haskell needed #stackage because of #cabalHell, whereas #purescript has both #nix integration and #dhall / #spago combo wombo, which is a less known "nix for language ecosystems".
But if this website (which I didn't understand beyond "I am certain I don't need this") provides `go get`-like experience, then it will be very good for beginners.
Just use #PureScript
These sort of umbrella resources help create a sense of cohesiveness in the community, making it more welcoming to newcomers. #Haskell is more popular, but it could still learn from how much #PureScript's community efforts have achieved in the past 2-3 years.
This is neat! https://purescri.pt
#purescript
@abnv @haskman you can compile #purescript to C++: https://github.com/andyarvanitis/purescript-native if you prefer C++ gotchas.
#PureScript is almost the perfect #Haskell replacement. Not only for the things it brings to the table, but also for the things it does *not*.
I mean actual *features* missing from PureScript and not gotchas like *no historical baggage*!
Some examples below. All of them are good for simplicity and newbie friendliness!
1. No laziness.
Laziness makes it harder to reason about performance. There are easy workarounds for most common usecases for laziness, and employing clever laziness tricks is usually not worth the cost of complicating the codebase.
Also, you can approximate thunks with functions when needed. Typeclass trickery even allows call-by-name evaluation (see https://github.com/natefaubion/purescript-call-by-name).
2. Manual recursion is discouraged.
PureScript's TCO only works in special cases. Normally you wouldn't even need to deal with this because existing implementations of functions like map, foldr etc. are already tail recursion safe. For the rare cases when you need to manually recurse, you can use `tailRec` and `tailRecM` to ensure stack safety.
3. No special syntax or support for linked lists. Strings are not simply lists of chars.
This could potentially be put in the "no historical baggage" category. But I feel that a lot of people, especially newbies, view the special treatment of lists and strings as a plus for Haskell.
However, the focus on lists causes massive confusion for newbies when they are encouraged to use types like Vector and Text in production instead. The special inbuilt syntax also is an active impediment for learning (for example, how do you refer to the higher kinded List type when deriving an instance? It's a mental leap to get to `[]` in `instance Foo [] where`).
4. No special syntax for Tuples.
Much of what was said for lists also applies to tuples. The special syntax is confusing to newbies and causes code complications. For example, each length of tuple is a separate type, and typeclasses in Haskell need to derive instances for each separately. They usually derive instances for tuples only up to length 7.
In addition, it's rarely needed. I am yet to find a usecase for tuples where PureScript's wonderful support for records doesn't suffice. I thought one such usecase was case matching on multiple values (`case (v1, v2) of ...`), but PureScript supports multi case match for this exact usecase and avoids unnecessary boxing (In PureScript you would write `case v1, v2 of ...`).
Searching for an interesting Web development project to tackle. The most important criteria is for it to be interesting and meaningful, willing to work for smaller fees for non-profits.
I have lots of experience with
Front-end tech: #Javascript #typescript #purescript #react #angular #html #css
Back-end tech: #nodejs #ruby #rails #sql #mongo
Also: #ux #ui #scrum #projectmanagement #design
github.com/abuseofnotation/
abuseofnotation.github.io/
Wrote about my #neovim config for #PureScript development - https://discourse.purescript.org/t/purescript-setup-with-neovim-lazyvim/3491
#LazyVim might just be the ide that tears me away from #Spacemacs!
A tech stack with #PureScript on the frontend AND backend, should be called the "pspsps" stack!
@haskman @chshersh correct. Also, and arguably most importantly, #purescript can share TYPES between a browser and server. Example of an approach to this: https://github.com/FrigoEU/purescript-endpoints-express
Even if you're not using #Purescript you can fill in the annual survey: https://www.surveymonkey.com/r/3X287PM
The #PureScript annual survey 2023 is now open! https://discourse.purescript.org/t/the-second-annual-purescript-survey/3436
George James is taking us through the steps of rolling your own cross platform UI framework with #PureScript!
4 Hours to go before the first event in #FPWebConf - George James' #PureScript talk!
Registration is free, register at the conf page (https://hasgeek.com/jsfoo/fp-webconf/) to get the participation zoom link for today's talk.
@pureevil Yup, #PureScript does dot notation for records (a.k.a. structs) only, and I like it for that sole purpose.
I dislike how #Haskell does dot notation so much that I made a meme about it -
I'm very pleased to announce the first talk as a part of the #FPWebConf series!
Join us for the on the 10th of March as George James talks about how and why Juspay built a cross platform UI framework using #PureScript, and how you can do the same.
Registration for the conf is free!
I asked what people thought of adding a record field projection syntax to PureScript -
foo = {x:1, y:true, z: Nothing}
bar = foo {.x, .y}
-- bar is now {x:1, y:true}
And Nate Faubion came up with a way to do it within PureScript's record system -
https://gist.github.com/natefaubion/365396bb83b582cd857e413cc2f963f5
It basically allows you to write
bar = prj foo :: { x :: _, y :: _ }
With the added bonus that upon compilation with the optimising backend, it will turn into something very similar to how you would write it by hand -
bar = {x: foo.x, y: foo.y}
The #PureScript community continues to be amazing!
A look at some functional abstractions that enable static analysis. #haskell #purescript
Submissions for the first #FPWebConf are open, and we are looking for speakers!
If you have explored functional programming for web development and would like to share your experiences, we would like to hear from you! Please submit a talk at the conf page - https://hasgeek.com/jsfoo/fp-webconf/
Boosts appreciated!
#functionalprogramming #webdevelopment #conference #india #haskell #purescript #elm #typescript #rustlang #scala #kotlin #clojure #fsharp #ocaml #reason
#Purescript has type signatures so simple even a Toddler could read and write them (forall a. Toddler a => HasPHDInMaths a => a -> PureScriptCode -> Effect Unit)
Announcing the “FP Web Conf” - a series of talks and in person events covering topics related to Functional Programming and Web Development. The events are free to attend, but don't forget to register on the website in advance! The first event is scheduled to take place in March this year.
https://hasgeek.com/jsfoo/fp-webconf/
We are also accepting proposals for talks and case studies. If you or your company has evaluated or adopted functional programming, we invite you to share your insights and experiences with the community!
#functionalprogramming #webdevelopment #conference #india #haskell #purescript #typescript #rustlang #scala #kotlin #clojure #fsharp #ocaml #reason
If you haven't tried #PureScript lately give it a go! There have been really exciting things happening in the past year or two that make PureScript the best option right now for web development.
In no particular order -
1. Spago and the new package registry. No more bower!
https://discourse.purescript.org/t/registry-alpha-launched/3146
2. Automatic formatting with purs-tidy.
https://discourse.purescript.org/t/announcing-purs-tidy-a-syntax-tidy-upper-for-purescript/2524
3. Spago2nix to automatically build nix derivations from spago.dhall.
https://discourse.purescript.org/t/nix-build-from-a-spago-dhall-the-final-missing-piece/3272
4. ESmodules support,
5. The new optimising compiler, and
6. The purescript-backend-es that uses the optimising compiler to implement a host of es specific improvements!
https://discourse.purescript.org/t/purs-backend-es-v1-3-0-released/3269
Not to mention the community is fantastic, the libraries and documentation are incredible, and the tooling works out of the box!
Someone asked me to use temp C to F conversion as an example instead of feet and inches, since with temp conversion the conversion is lossy both ways and you can't have a single source of truth.
Never fear, you can just use an `Either C F` and switch your source of truth on the fly! The code is still extremely concise and clear (and bug free).
```
converter :: Either C F -> Widget HTML (Either C F)
converter e = D.div'
[ Left <$> counter "C" (toC e)
, Right <$> counter "F" (toF e)
]
where
toF = either cToF identity
toC = either identity fToC
cToF :: C -> F
cToF c = ((c * 9) / 5) + 32
fToC :: F -> C
fToC f = ((f - 32) * 5) / 9
```
#SumTypes and strongly typed #FunctionalProgramming for the win! #PureScript #Concur
Just updated the packages for #PureScript #Concur starter repo. Also updated the sample code to be a bit less trivial. The sample app now also acts as a mini tutorial and demonstrates some important Concur concepts! Check out the code here - https://github.com/purescript-concur/purescript-concur-starter/blob/main/src/Main.purs
Nothing like writing a bunch of Elm code to make me appreciate #purescript Halogen
Interpolation of Records of Values in #Purescript
I just blogged about another interesting type journey in #PureScript: How to interpolate whole records of numeric data. https://blog.galowicz.de/2023/01/30/purescript-interpolation-of-records/
@justinhj what lead you to take a look at #purescript? What about #scalajs or #elmlang ?
Just realised that #PureScript record update syntax is quirky. 🤔
If you have the following defined -
```foo = {x:1, y: false, z: false}```
This gives you a type error (can't match Boolean with Int) -
```bar = Record.merge (foo {z = 1}) {}```
But this works -
```bar = Record.merge baz {}
where baz = foo {z = 1}```
What do you think of a record field selector syntax for #PureScript? Something like -
foo = {x:1, y:true, z: Nothing}
bar = foo {.x, .y}
Bar will now be == {x:1, y:true}
Here is some IR of my scope-safe compiler (https://github.com/cgohla/pureshell/). Trying out my new pretty printer.
Building an HTTP API with HTTPurple is a real delight.
who controls the controller? Me.😂
When they write formal verification in #purescript to discover complex bugs in the applications under test and I find a subtle bug🐞 in their #selenium property-based automated acceptance testing tool:
🔗
https://github.com/quickstrom/quickstrom/issues/120
absolutely! I really liked fullstack #purescript because it could have done this: https://github.com/thoughtflare/purescript-endpoints-express/blob/master/example/src/EndpointExample/Model.purs#L13
If you roam around other files, you'll see that `Order` is shared between the client and server. It has a bit of an Argonaut bolierplate, but it's kinda ok.
I think this repo is certainly something to check out, and in general, reaching out to @FrigoEU on Github would be a nice idea to help with the design.
I guess I should do an #introduction rather than just lurk.
I’m a software engineer turned manager with a varied background in both tech stack and industry. I work at #Playstation and love to dabble in #functionalprogramming and #purescript when I have time.
Keen on taking back my online #Privacy and slowly trying to kick tech giants to the curb.
I’m a husband and dad, and love the outdoors. I’m a UW-Madison alum and used to bike year round in #wisconsin when office work was the norm.
Hi! :)
[3/3]
Then I've moved on to my current job where I use:
* #python to write web crawlers and web scrapers while monitoring their status
* #haskell to work on internal tooling and some analytics projects
* and again #haskell (and sometimes #purescript ) on a fairly new healthcare web app project for the last 2+ years.
---
Thank you for your time and feel free to check out my LinkedIn profile (or hit me with questions) if you're further interested.
Hi there! I'm Matt. This is my #introduction.
I have been in #SoftwareDevelopment since 2001 and spent most of my career working with #PHP.
My day job involves #Node and #TypeScript. I also dabble with languages like #Clojure and #PureScript and aspire to learn more about #FunctionalProgramming.
I love #OpenSource, #OpenStandards, and #ComputerScience.
When not coding, I enjoy reading (#SciFi / #SFF in particular), writing, singing / #karaoke, and story- and strategy-focused #gaming.
Reactivating — Hello! I’m into:
• Functional programming, especially #haskell, #ocaml, #elmlang, #purescript
• Proof systems & software correctness tools #coq, #idris, #agda, #rustlang
• Scientific data acquisition & analysis, #gpu frameworks
• Reproducible builds, #nixos, #nixpkgs
• Non-traditional families (#queer, interracial)
• #ADHD strategies & other #neurodivergent perspectives
• Black natural hair care, for Ms. 7yo
• #Classical & electronic music, dabbling at piano as a busy adult