Search
324 results for “typelevel”
-
CW: Typelevel, good first issue
If anyone wants to dip their toe into the waters of open source, this is an easy first pull request. I can explain more if it's not clear what's going on there. Please comment on the issue if you want to take it.
-
Article showing off a cool new library that illustrates #Actors and #FP working cleanly together using the #Typelevel type classes.
I may well wind up evolving #Querki towards this in the medium term: that's fundamentally Akka-centric now, and I've long wanted to move it towards Cats-effect 3.
https://mastodon.social/@cloudmark/112615743584339619 -
On #Scala's #CatsEffect library — one common myth is that it's a library built for “tagless final” (TF).
While it's true that it gives you unparalleled ability to use TF and monad transformer stacks, it's perfectly usable without. Most libraries from #Typelevel are.
-
I created a #chatgpt #Scala Cats Effect Tutor for fun take a look all:
https://chat.openai.com/g/g-anUfWL8Ty-scala-cats-effect-tutor
Feedback to make it better appreciated. I will be iterating on it, this is just an initial attempt.
Have fun all!
cc @typelevel
-
The upcoming twenty-fourth patch release in the `0.23`-series of http4s got 7 (seven!) new contributors. In fact, their contributions enrol into 2/3 of all shipped changes. Goddamn, that doesn't stop to blow my mind!
#Typelevel #http4s #scala -
I kind of hesitated with posting about it here but I'm happy to announce that my project got selected for this years #GSoC under the @typelevel organization!
Over the course of the project I will be prototyping a port of Cats Effect and FS2 for the #Wasm/WASI platform. Support for WASI by #scala compiler(s) is still experimental and I think this is the first time an I/O-heavy library is being ported there
-
Cats-Effect 3.6.0 is a very exciting release due to the work on its internal work scheduler, many congrats to its contributors! ❤️
https://github.com/typelevel/cats-effect/releases/tag/v3.6.0
-
Type-level программирование в TypeScript: практические кейсы и новые возможности
Как использовать мощь системы типов TypeScript для вычисления логики ещё на этапе компиляции и автоматической генерации кода. Разбираем условные типы, шаблонные литералы, рекурсивные типы и другие приёмы, чтобы упростить разработку, сократить дублирование кода и снизить вероятность ошибок на runtime.
https://habr.com/ru/articles/871336/
#typescript #Typelevel_программирование #метапрограммирование #условные_типы #типобезопасность #Валидация_типов #рекурсивные_типы #mapped_types #Шаблонные_литералы_типов
-
Cats-Effect 3.6.0-RC1 comes with some very exciting changes ❤️ Congrats to the team, they keep delivering 😍
https://github.com/typelevel/cats-effect/releases/tag/v3.6.0-RC1
-
Hi all 👋
I'm moving from https://mastodon.social/@alexelcu, again; still experimenting, and with a self-control problem 😅
I'm a #programmer. I love #StaticTyping and #FunctionalProgramming on top of #Scala, #Kotlin, and #Haskell. I'm from #Bucharest, #Romania, and I like to contribute to programming libraries.
I write at https://alexn.org, and I contributed to https://monix.io and to https://typelevel.org.
My bois said hi 👋
-
Currently, I am using a Cofree like DirTree data structure in #Akka to keep track of the actors responsible for a given resource so that we can send HTTP messages directly to them.
```scala
case class DirTree[R](
ref: R,
kids: HashMap[String, DirTree[R, A]] = HashMap()
):
```
https://github.com/co-operating-systems/Reactive-SoLiD/blob/30d6fd46fe30bc8be350c4a09d8592b20b791aa7/src/main/scala/run/cosy/ldp/DirTree.scala#L135I am synchronizing that with a #Java AtomicReference currently. I wonder if @alexelcu setup would make it easier to use a #CatsEffect Ref. One thing I had been thinking of is of wrapping the children in a `Ref` so that one would need to update only parts of the subtree if needed.
```scala
case class DirTree[R](
data: R,
kids: Ref[HashMap[String, DirTree[R]]]
):
```
https://www.pluralsight.com/tech-blog/scala-cats-effect-ref/By the way it should be quite easy to see why DirTree is just the Cofree Commonad with
```scala
type DirTree[A] = Cofree[Map[String,?],A]
```
But I can't quite see the advantages of using the Cofree right now.
https://typelevel.org/cats/api/cats/free/Cofree.html -
how exciting, Maksym Ochenashko is writing a series on #observability in #scala applications! Maks is a prolific maintainer of #otel4s and #cats-effect.
-
Glowstick – type level tensor shapes in stable rust
https://github.com/nicksenger/glowstick
#HackerNews #Glowstick #stable #rust #tensor #shapes #programming #Rust #HN
-
Something I would like to make in #rust is a #libc wrapper that uses type-level contracts and optional (maybe debug-by-default) runtime checks. I like Rustix, but I'd like to make something that you can use with magnitudes less footguns.
If you know of a company/team that would be willing to fund such work, I'd be eager to get connected!
#FediHire #contracting
(Please reply with suggested hashtags, I'm not the greatest at these xD) -
@rauschma It is six months until April. How about we collaborate on a type-level typescript edition of SICP, to drop on 2026-04-01?
-
Also, if you ever wondered why #SpringJavaFormat / #Checkstyle ask the first sentence of a type-level JavaDoc comment to end with a period, the screenshot shows why :)
It will become the value of `Description` in the overview.
-
The revised version of our #Platynereis #connectome paper is now out:
https://elifesciences.org/reviewed-preprints/97964
Cell-type-level annotation of the whole organisms, including synaptic and desmosomal connectomes. Can be explored with CATMAID here:
https://catmaid-jekelylab.cos.uni-heidelberg.de
#larva #marine #neuroscience #vEM -
The revised version of our #Platynereis #connectome paper is now out:
https://elifesciences.org/reviewed-preprints/97964
Cell-type-level annotation of the whole organisms, including synaptic and desmosomal connectomes. Can be explored with CATMAID here:
https://catmaid-jekelylab.cos.uni-heidelberg.de
#larva #marine #neuroscience #vEM -
The revised version of our #Platynereis #connectome paper is now out:
https://elifesciences.org/reviewed-preprints/97964
Cell-type-level annotation of the whole organisms, including synaptic and desmosomal connectomes. Can be explored with CATMAID here:
https://catmaid-jekelylab.cos.uni-heidelberg.de
#larva #marine #neuroscience #vEM -
Spectre is a programming language meant for safe and contract based low-level systems programming.
It allows for type-level invariants, and function-level preconditions and postconditions, it enables safety through use of immutability by default. -
Spectre is a programming language meant for safe and contract based low-level systems programming.
It allows for type-level invariants, and function-level preconditions and postconditions, it enables safety through use of immutability by default. -
Spectre is a programming language meant for safe and contract based low-level systems programming.
It allows for type-level invariants, and function-level preconditions and postconditions, it enables safety through use of immutability by default. -
Spectre is a programming language meant for safe and contract based low-level systems programming.
It allows for type-level invariants, and function-level preconditions and postconditions, it enables safety through use of immutability by default. -
Spectre is a programming language meant for safe and contract based low-level systems programming.
It allows for type-level invariants, and function-level preconditions and postconditions, it enables safety through use of immutability by default. -
Oh nice. Just found 2 #rustlang nightly features which look like they might bring us closer to one of the two major type level things Iam missing hard in #rust : "extistenia types" (the other one are #GADT)
type_alias_impl_trait:
https://doc.rust-lang.org/unstable-book/language-features/type-alias-impl-trait.htmlimpl_trait_in_assoc_type:
https://doc.rust-lang.org/nightly/unstable-book/language-features/impl-trait-in-assoc-type.html -
I've been working with the Yesod web framework for 3 months now and it feels very untyped, inspite of its tagline, "Creation of type-safe, RESTful web applications". So many constraints are not encapsulated in the types. Furthermore, there is little separation of levels of abstraction.
I'm looking forward to learning Servant. Based on its research paper, it looks very promising thanks to its usage of type-level features!
#Haskell #typesystem #functionalprogramming #web #Yesod #Servant #REST
-
Here's a #TypeScript API design challenge I'm working on: adding async support to #Optique (CLI argument parser) without breaking the existing sync API.
The tricky part is combinators—when you compose parsers with
object()oror(), the combined parser should automatically become async if any child parser is async, but stay sync if all children are sync. This “mode propagation” needs to work at both type level and runtime.I've prototyped two approaches and documented findings. If you've tackled similar dual-mode API designs, I'd love to hear how you approached it.
-
Now that my son is back home, unscathed, I shall deliberately steer my mind away from the unsettling topic of #BrownUniversity #shooting, and switch back to my comfortable stomping ground: programming languages.
For more than five decades, mathematicians, logicians, philosophers, and computer scientists have been profitably using the succinct, cogent, 2D mathematical notation in their type theoretic publications. Yet, the dependently typed languages, despite their modernity, struggle with their 1D type-level syntaxes. These languages, by their very nature, demand from the user a level of mathematical sophistication uncommon amongst the IT JavaScript webapp coders. As such, the only ones who are currently using these languages are those programmers with a mathematical bent.
So, these languages might as well drop their 1D syntactic pretences, and adopt the 2D syntax adapted from the mathematical notation universally used in simple, dependent, and homotopy type theoretic publications—something akin to the syntax of #Epigram.
-
I am a #ComputerScientist who is not a trained theoretician. As such, I find #DependentTypes not only intellectually stimulating (that is, challenging) but also practically attractive (albeit potentially, at present).
Using a dependently typed language, many vexing run-time checks that pollute the code could be off-loaded to the compile-time type checking, thereby leaving the logic flow clean, concise, comprehensible, and well, you know. Off-the-cuff examples abound: matrix multiplications without run-time checks for dimensional compatibility, sorted lists that need no run-time assurances of order, etc.
But these thoughts niggle me:
• BOUNDARY—Many modern, strongly, statically typed languages, like TypeScript, Zig, etc., have type systems that are Turing complete (unintentionally and with the attendant ⊥). It would be nonsensical to transfer all computing from run-time to compile-time. So, how do we, #programmers, discern this allusive boundary?
• ERGONOMICS—At present, most dependently typed languages and simply typed languages with Turing-complete type systems have rather ill syntax for type expressions. I am tempted to save Agda from this rather sweeping swipe, but even my beloved Agda's type-level syntax could use a bit of tidying up. If language designers insist upon foisting dependent types upon us, they ought to pay attention to the syntactic ergonomics of the type-level expressions as much as they do that of the value-level expressions.
-
followed by #TheLevellers with #LayMeDown as it sums up my current state of mind tonight on #MusicBeforeBedtime