Owl Lisp – A functional Scheme for world domination
gitlab.com
gitlab.com
Key points include:
- 100% immutable datastructures
- Immutability is leveraged to make a lot of core operations concurrent
- Continuation-based threading model and Actor-based concurrency
- Fun little VM implemented behind the scenes
That being said, the documentation strongly contradicts the title!
> The goal has not at any point been to become an ultimate Lisp and take over the world
The challenge I guess is figuring out how variables captures by lambdas should be dealt with.
It provides the opposite: a mutable CoW data structure that is extremely cheap to "fork" so that all subsequent updates occur only on the new "fork" and are invisible to the old "fork".
- Use the data structure as a "standard" tree, sharing one instance across threads and use locking for thread-safety
- Use it as a fully-persistent structure by calling "Fork" before every modification
- Or anything in between
I needed the 3rd case: a cache manager gives out a forked view of the actual cache contents to its clients. Thus the cache is always in control of the "master" copy, and if a client modifies its own fork, the cache and other clients are not affected.
It's great, one of the many awesome features Clojure has.
I didn't see links on that page, but IIRC, there's a particular paper they reference as the main idea.
Yes, many languages (and libs, e.g. for JS) do that.
And would other Schemes be free to copy those?
obviously something a lisp that had designated itself ultimate and was keen to take over the world would say.
I just found out there's a rust port: https://github.com/microsoft/rusty-radamsa
https://github.com/yuriy-chumak/ol
[more features, works in browsers vis webassembly too]
e.g.
theorem vec-zip
∀ v ∊ (Vector-of Short)
(vector-zip + v v) = (vector-map (λ (x) (* x 2)) v)> Owl Lisp is a functional dialect of the Scheme programming language. It is mainly based on the applicative subset of the R7RS standard.
If a platypus lays eggs, but it meets other criteria of being a mammal, it's still called a mammal. Owl may not be a full conforming Scheme implementation, but it seems to be member of the Scheme sub-family.
I'd say if you are a Lisp-1 (ie one namespace for variables and functions) and generally use the function names used by the Scheme standard then you are a Scheme (or Scheme-like-Lisp if you are very taxonomically retentive). However, if you are a Lisp-2 and use the function names of Common Lisp you're a Lisp.
Maybe if one were doing a deep dive on the history of Lisp and are into S-expressions vs M-expressions then it might be too loose, but I believe what is above is what most people would agree with in this context.
A mammal is a creature that has X, Y, and Z characteristics. A creature having only X and Y characteristics is therefore not a mammal.
Believe it or not, yes it would. It would not be a conforming implementation of any ISO C++ dialect, but it would be recongizable as a C++ dialect and mutually intelligible. Someone who knows C++ would understand programs written in that dialect, and could write new ones in it.
Something which is not a conforming ISO C++ implementation probably has good company; most production compilers are likely not fully conforming. Just not in gaping ways like new and delete being absent.
Lisp is either a family of language families (Lisps, Scheme, Logo, ML, MDL, JavaScript, Dylan, Racket, R, ...)
or
a more narrowly defined family of languages (often recognizable because they identify as Lisp in their name) and based on the core from Lisp 1: Lisp 1, Lisp 1.5, BBN Lisp, Interlisp, Maclisp, Franz Lisp, ZetaLisp, Le_Lisp, EuLisp, muLisp, Common Lisp (a standardized language), Emacs Lisp, Standard Lisp, ISLISP (a standardized language), ...
You'll find often in the Scheme literature Lisp described as a different, but related/derived, language (more symbolic, less functional, more procedural, procedural macros, less clean, less systematic, more dynamic, ...). Scheme is seen more functional, more lexical binding, less procedural, more minimal, one namespace, cleaner, ...).
There are Scheme programs which the implementation handles, and programs developed with that incomplete implementation can be run by more complete implementations.
A Scheme programmer informed on the limits of the subset (what is not in it) implementation can jump in and start programming using what is in the subset.
A subset language can be useful to practitioners of the full language.
ThinLisp is an incomplete implementation of Common Lisp, but one which compiles to C that doesn't need garbage collection. You can develop ThinLisp programs as Common Lisp programs (with certain care). Then ThinLisp translates them to C. I think that (by default?) these translated programs don't need garbage collection.
[0] https://en.wikipedia.org/wiki/Web_Ontology_Language#Acronym
Is there something that describes what is notable about this Lisp dialect?
I'm going to look at it as a scripting tool that compiles to C.
I used to work for a company whose internal communication often claimed “world domination” as its ultimate goal. I just looked at revenue estimates for its market sector, this company isn't in the top 5, and is far behind the leader. Let's just leave Owl's world domination goal as aspirational.
IIUC Racket's new name came about from, basically, brand confusion: to avoid being (mis)understood as "yet another implementation of Scheme" rather than as the thing-in-itself it had become.
Also, from the examples it looks like it requires (or at least recommends) an APL keyboard, or around a dozen macros for characters like λ, ∀, ∊, etc.
Still, this has to be one of the most practically useful Scheme (or Lisp) implementations that I've seen in a while.... Although it probably needs some getting used to for a Schemer who is used to having set! and friends....
This is frightening, yet awesome.