microKanren
trial
microKanren | trial | |
---|---|---|
2 | 10 | |
298 | 840 | |
- | 3.0% | |
0.0 | 9.9 | |
almost 10 years ago | 2 days ago | |
Scheme | Common Lisp | |
- | zlib License |
Stars - the number of stars that a project has on GitHub. Growth - month over month growth in stars.
Activity is a relative number indicating how actively a project is being developed. Recent commits have higher weight than older ones.
For example, an activity of 9.0 indicates that a project is amongst the top 10% of the most actively developed projects that we are tracking.
microKanren
-
Lisp-Stick on a Python
which uses a Lisp to define itself. This means roughly that if you understand enough Lisp to understand this program (and the little recursive offshoots like eval-cond), there is nothing else that you have to learn about Lisp. You officially have read the whole language reference and it is all down to libraries after that. Compare e.g. with trying to write Rust in Rust where I don't think it could be such a short program, so it takes years to feel like you fully understand Rust.
Indirectly this also means that lisps are very close at hand for “I want to add a scripting language onto this thing but I don't want to, say, embed the whole Lua interpreter” and it allows you to store user programs in a JSON column, say. You also can adapt this to serialize environments so that you can send a read-only lexical closure from computer to computer, plenty of situations like that.
Aside from the most famous, you have things like this:
1. The heart of logic programming is also only about 50 lines of Scheme if you want to read that:
https://github.com/jasonhemann/microKanren/blob/master/micro...
2. Hygienic macros in Rust probably owe their existence to their appearance in Lisps.
C2 asks the same question here: https://wiki.c2.com/?LispShowOffExamples with answers like
3. The object model available in Common Lisp was more powerful than languages like Java/C++ because it had to fit into Lisp terms (“the art of the metaobject protocol” was the 1991 book that explained the more powerful substructure lurking underneath this object system), so a CL programmer could maybe use it to write a quick sort of aspect-oriented programming that would match your needs.
4. Over there a link shows how in 16 LOC you can implement a new domain-specific language to define and run finite state machines: http://www.findinglisp.com/blog/2004/06/automaton-cleanup.ht...
-
William Byrd on Logic and Relational Programming, MiniKanren (2014)
> I think that with such modern additions (i.e. apart from the cut) Prolog moves closer to the declarative ideal without sacrificing its all-around usability as a general purpose language. What do you think?
I also used to think that Prolog was moving closer to the delcarative ideal. And I suspect that most expert Prolog programmers believe similarly.
However, my attitude has changed in the past few years, after seeing Prolog programmers try to implement the relational interpreter from the 2017 ICFP pearl in Prolog.
The problem is one of composing the pure features needed for expressing a program as complicated as the relational interpreter. (Of course, the relational interpreter is designed to be as short and simple as possible, bit it is still more complicated than pure relations you will find in a Prolog textbook, for example.)
In theory, you can easily combine unification with the occurs check, SLG-resolution, disequality/disunification constraints, type constraints, etc., and avoid all impure uses of extra-logical features. In practice, I've seen people struggle to combine these features within a single Prolog implementation. In fact, after multiple attempts from multiple Prolog experts, I have yet to see a version of the relational Scheme interpreter in Prolog that can match the behavior of the miniKanren version.
I'm not claiming that someone couldn't implement a full relational interpreter in Prolog. Obviously they could, since Prolog is Turing-complete. I'm only saying that the default choices of Prolog, plus the intricacies of combining multiple pure features (and leaving out standard and useful non-relational features), seems to make writing a relational interpreter much harder than I would have expected.
If you are up for a challenge, I'd be happy to work on a Prolog version of the Scheme interpreter with you!
Based on what I've seen from Prolog experts trying to reproduce the relational interpreter, and conversations with Prolog experts, my current thinking is that Prolog is actually not a good language for relational programming. Too many of the defaults must be adjusted or overridden, too many standard techniques and idioms must be abandoned, and too many potentially incompatible libraries must be composed in order to get everything "just right."
The problem isn't that relational programming in Prolog isn't possible. The problem is that it requires enough work and non-standard techniques that in practice people don't do it.
At least, that is what I observe as an outsider.
If there is an easy way to combine features within a single FOSS Prolog implementation to allow for the types of relational programming we do in miniKanren, I'd be delighted to see it in action. I'd also be delighted to write a paper about it with you! :)
> Finally, I'd like to know more about minikanrens' search. I'll look around on the internet, but is there a source you would recommend?
I would recommend reading Jason Hemann and Dan Friedman's lovely little paper on microKanren, which gives a tutorial reconstruction of miniKanren's complete interleaving search, starting from depth-first search:
http://webyrd.net/scheme-2013/papers/HemannMuKanren2013.pdf
https://github.com/jasonhemann/microKanren
The standard exercise for learning microKanren is to translate the resulting ~50 lines of Scheme code into the language of your choice.
You might also like this more technical paper on the `LogicT` monad:
Backtracking, interleaving, and terminating monad transformers: (functional pearl)
trial
- Trial Game Engine Issue
-
Submissions to Spring Lisp Game Jam 2023
Little Spark - made with Trial
- Show HN: Kandria, an action RPG made in Common Lisp is now out
-
Kandria, an action RPG written in Common Lisp releases in a week on January 11!
The engine is called Trial. https://github.com/shirakumo/trial.
- Lisp-Stick on a Python
-
interested in learning lisp, (specifically for games, but also for everything else including tui and gui applications for linux. currently have next to no programming knowledge, can i get forwarded some resources and some tips on what exactly i should do? any videos i should watch?
I don't know what the situation is like for 3D game programming in CL. Shinmera recently kickstarted a game but it's 2D I think and I don't know if his engine (https://github.com/Shirakumo/trial) does 3D. But regardless of what you're using, going into learning how to program while also trying to learn how to use the game engines available in the CL world will probably be a recipe for getting overwhelmed and discouraged. I'd recommend going through the Steve Losh post first and reading A Gentle Introduction to Symbolic Computation and/or Practical Common Lisp to get some solid general familiarity with using CL. Both are available online for free. You can also browse through the Cookbook: https://lispcookbook.github.io/cl-cookbook/
-
Common lisp game development libraries
For graphics there's a lot of different variants and options. I use Trial, but that doesn't have any docs yet, I'm afraid.
- Trial: A fully-fledged Common Lisp game engine
-
Our Lisp game, Eternia: Pet Whisperer is now out on Steam!
Kandria and Eternia both are built on top of the game engine Trial, which I and a few others at Shirakumo have been working on for some years now. Trial itself makes use of a bunch of lower level libraries like cl-opengl, GLFW, pngload, harmony, etc. but a huge amount of the codebase was written by me. If you're interested in its development, I recommend hopping by the #shirakumo channel on the Freenode IRC network. I'd be happy to answer questions there!
-
Idiomatic way to handle non GC objects, i.e. OpenGL textures ?
A good way to do it is to keep a staging area of sorts that keeps track of the manually allocated objects and their state. When you allocate you batch all objects to allocate together and then execute the load in one go, updating the records in the staging area. Then, when you're ready to switch to a different scene or whatever, you diff the staging area against the current set of objects that need to be live and deallocate everything else in one go.
What are some alternatives?
mediKanren - Proof-of-concept for reasoning over the SemMedDB knowledge base, using miniKanren + heuristics + indexing.
raylib - A simple and easy-to-use library to enjoy videogames programming
dissertation-single-spaced - Single-spaced version of my dissertation, 'Relational Programming in miniKanren: Techniques, Applications, and Implementations'
ulubis - A Wayland compositor written in Common Lisp
calysto_scheme - A Scheme kernel for Jupyter that can use Python libraries
Panda3D - Powerful, mature open-source cross-platform game engine for Python and C++, developed by Disney and CMU
clinch - Common Lisp 3D/2D Graphics Engine for OpenGL
trivial-gamekit - Simple framework for making 2D games
legit - CL interface to the GIT binary.
cffi - The Common Foreign Function Interface
Shin-Barliman - Research project: Program synthesis using updated interface, template and types.
magnum - Lightweight and modular C++11 graphics middleware for games and data visualization