| Age | Commit message (Collapse) | Author |
|---|
|
|
|
|
|
Gives a hand from a shuffled deck to the user, asks them to provide
indices for cards they wish to re-deal then does so.
|
|
|
|
This new version is terser while still expressing what I want.
|
|
`$` takes a list of forms and makes a unary function which applies
them via `->>`. Previous definition reversed the forms supplied
s.t. `$` was closer to the applicative operator in Haskell i.e. the
function (<$> f g) is f(g(x)). But this version fits closer with the
lower operator (->>) being used AND allows easier lifting from
`->>` (which produces a value) to `$` (which produces a function).
|
|
Joker constructor takes a rank for uniqueness - rank doesn't really
change anything in terms of the "power" of a joker but helps with
ensuring jokers are unique in a deck.
Deck constructor takes an optional argument for the number of decks.
A deck includes two jokers, so n decks include 2n jokers.
|
|
Because I assume n is modded already.
|
|
I can now use this package for a console application since we can
pretty print cards.
|
|
|
|
Generally, ACE is the best card in Cantedraw in a card-by-card basis
thus it should be the higher when comparing.
|
|
Given n in 0..51, certainly there exists r, s s.t. `n = 13s + r`
where r in 0..12 and s in 0..3. `r` is the rank, and `s` is the suit.
ranks are ordered Ace, 2, 3, ..., Queen, King and suits are ordered
Diamond, Club, Heart, Spade.
Therefore there is a 1-1 correspondence between 0..51 and any card in
the deck.
Jokers are a bit less straightforward; for now I'll define them as an
outlier which doesn't exist in the same bounds (which is why they're
the default return for suit in int->suit). Likely I'll go for -1
representing a Joker.
|
|
Time to do the fun non-yakshaving part. I'll start out by writing
some custom types for the objects of concern: ranks, suits, cards and
sets of cards.
|
|
Instead of exporting cantedraw.lib.macro._ and making anyone who wants
to use the --> macro _require_ importing that specific symbol, let's
just make it so the user has to supply a placeholder name before they
do anything. This means each package provides its own placeholder
symbol which lowers coupling.
|
|
This is mostly a sanity check in-case anyone else decides to load this
system for use in their own package - don't want to conflict with
their names.
|
|
|
|
|
|
|
|
|
|
Why name it something unique when this is what I'm going to be making
at the end of it all? Just makes it more confusing for the end user.
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
f $ g $ h -> f(g(h)) whereas previous implementation ($ f g h) was
h(g(f)).
|
|
Given an indicator function (A->B) and a list of items of A, return
an association list associating B to the elements that map to it;
essentially the inverse map of the indicator.
|
|
|
|
bob.lisp quickloads the dependencies necessary and defines functions
which I can just call from my REPL to load or build the project.
Better than loading the file over and over again. Affectionately
named after "Bob The Builder".
|
|
Given a list and index into that list, return a cons where the car is
all elements up to that index (exclusive) and the cdr is the rest of
the list.
|
|
Basically a wrapper over subseq but for when using `->>` as the list
is the last parameter.
|
|
The `$` operator takes a sequence of FORMS and returns a unary
function which applies the input through that sequence via the `->>`
operator.
For example, consider the predicate "not null". `null` is built into
Common Lisp but "not null" requires writing a
function (lambda (x) (not (null x))). Now, using this operator, you
can write ($ not null) which returns the same lambda as above while
being more concise.
|
|
|
|
Splitting macros and functions into different packages and source code
makes it easier to look at. Functions currently implemented:
- range: like Python's range
- parse-integer*: parse-integer but junk-allowed is set to t.
|
|
|
|
|
|
`fn' is a convenience macro for defining functions with a type
specifier. Only really matters for `sbcl` and other hard-optimising
Lisp interpreters which actually take these seriously.
|
|
Allows junk, and doesn't crash horribly.
|
|
|
|
|
|
|
|
Setup boilerplate for system/package management. In particular, setup
an entry-point and Shinmera's "deploy" to build executables.
Also write some scripts to easily load or build the project without
Emacs - just `sbcl --load <x>.lisp`.
|
