Common Lisp polymorphic stories.

This page summarizes the projects mentioned and recommended in the original post on reddit.com/r/lisp

Our great sponsors
  • SonarLint - Deliver Cleaner and Safer Code - Right in Your IDE of Choice!
  • Scout APM - Less time debugging, more time building
  • OPS - Build and Run Open Source Unikernels
  • GitHub repo generic-cl

    Generic function interface to standard Common Lisp functions

    Anyway, this library is inspired by https://github.com/alex-gutev/generic-cl and provides polymorphic versions of many common standard functions based on types. For example, now `>` and `

  • GitHub repo cl-form-types

    Library for determining the types of Common Lisp forms based on information stored in the environment.

    Anyway, this library is inspired by https://github.com/alex-gutev/generic-cl and provides polymorphic versions of many common standard functions based on types. For example, now `>` and `

  • SonarLint

    Deliver Cleaner and Safer Code - Right in Your IDE of Choice!. SonarLint is a free and open source IDE extension that identifies and catches bugs and vulnerabilities as you code, directly in the IDE. Install from your favorite IDE marketplace today.

  • GitHub repo polymorphic-functions

    A function type to dispatch on types instead of classes with partial support for dispatching on optional and keyword argument types.

    Before reading this, please go and check out https://github.com/digikar99/polymorphic-functions which this project is fully based on. It's great.

  • GitHub repo coalton

    Coalton is an efficient, statically typed functional programming language that supercharges Common Lisp.

    coalton you mean?

  • GitHub repo abstract-arrays

    A structure and some facilities for an abstract-array structure in common lisp

    And, there won't be a way to properly understand what exactly PF (or CL) misses without immersing myself into a ML-style something, is there? As in, I get some parts of what you are saying; I myself had to (ab)use deftype and gensym intern for another library for providing (limited) parametric types; but I also fail to see something seriously wrong with it, given that it plays nicely with cl:declare, cl:typep and cl:subtypep for the primitive use case of single value type checking, declaration and with some additional things (compiler)macro based optimization.

  • GitHub repo polymorph.maths

    Maths for polymorph.stl

    Example: your equality polymorph here https://github.com/lisp-polymorph/polymorph.maths/blob/master/src/polymorph.maths.lisp

  • GitHub repo fast-generic-functions

    Seal your generic functions for an extra boost in performance.

    About static typing and generic functions, are there limitations to fast-generic-functions built over sealable-metaobjects too? I felt that reasonable, albeit it takes away the dynamic nature of the objects after sealing.

  • Scout APM

    Less time debugging, more time building. Scout APM allows you to find and fix performance issues with no hassle. Now with error monitoring and external services monitoring, Scout is a developer's best friend when it comes to application development.

  • GitHub repo sealable-metaobjects

    A CLOSsy way to trade genericity for performance.

    About static typing and generic functions, are there limitations to fast-generic-functions built over sealable-metaobjects too? I felt that reasonable, albeit it takes away the dynamic nature of the objects after sealing.

  • GitHub repo ccl

    Clozure Common Lisp

    Well, CCL has a bug pertaining to signatures of funcallable-instances that may prevent things from working in certain cases.

  • GitHub repo ctype

    CL type system implementation

    Other times, the support is limited by the implementations supported by ctype and cl-form-types (and cl-environments). Although, if there is any good request, I could work on making a dynamic-only ANSI-CL compliant sub-system of PF.

  • GitHub repo lisp-interface-library

    LIL: abstract interfaces and supporting concrete data-structures in Common Lisp

    What are your thoughts on the Lisp Interface Library? I recognize that it doesn't cover some of your use cases since LIL is designed in a dynamic manner and does not provide the sort of compile-time type shenanigans that coalton can. Just from the standpoint of providing parametric polymorphism though, dynamic or not, what do you think of it?

NOTE: The number of mentions on this list indicates mentions on common posts plus user suggested alternatives. Hence, a higher number means a more popular project.

Suggest a related project

Related posts