Hi Charles,

First, thanks for your offer to help with FreeCell, but please see my comments there responding to the two issues you raised. I would like to understand docs and coverage for some of my other packages and would welcome your assistance.

Now to the main point:

I tested my cut and riffle functions on your implementation of PlayingCards and they work fine. Do you want to include this functionality? If so, you can just copy the file
shuffle.jl
to your src directory and add the line include("shuffle.jl") to PlayingCards.jl.

Ed

Joker cards may be good placeholders to enforce type stability.

Users may want to make custom decks, so we should provide an abstract type for that.

Hi again. I'd like to see the functions low_value and high_value defined for all cards.

julia> C = 5♠
5♠

julia> value(C)
5

julia> high_value(C)
ERROR: UndefVarError: high_value not defined
Stacktrace:
 [1] top-level scope
   @ REPL[15]:1

julia> low_value(C)
5

For Poker, you'd want to use high_value; for solitaire, I'd use low_value. This makes PlayingCards "agnostic" about ace high vs. ace low.

My further suggestion is not to define value at all, and let the user either choose which value function to use, or else define their own function either value=low_value or value=high_value.

Let me know if you'd like me to edit PlayingCards.jl to implement, or send some code snippets you can cut/paste.

Thanks,
Ed

Hi Charlie:

Is this the behavior you want?

julia> using PlayingCards

julia> [ k*♣ for k=1:13 ]
13-element Vector{Card{_A, Club} where _A<:Rank}:
 1♣
 2♣
 3♣
 4♣
 5♣
 6♣
 7♣
 8♣
 9♣
 T♣
 11♣
 12♣
 13♣

I've got mine rigged to do this:

julia> using PlayingCards52

julia> [ k*♣ for k=1:13 ]
13-element Vector{Card}:
 A♣
 2♣
 3♣
 4♣
 5♣
 6♣
 7♣
 8♣
 9♣
 T♣
 J♣
 Q♣
 K♣

We might as well define this here. It would be useful if users could use a deck that has a non-allocating pop! function-- where we internally track which cards have been popped (to avoid allocations).

As part of some font testing recently, I worked out how to use the Unicode playing cards glyphs. Here's an alternative show() method that should work, if there are fonts around with the requisite symbols.

function Base.show(io::IO, c::Card)
    r = rank(c)
    # ace of spades   : u1F0A1 :   0
    # ace of hearts   : u1F0B1 : + 16
    # ace of diamonds : u1F0C1 : + 32
    # ace of clubs    : u1F0D1 : + 48
    if 1 ≤ r ≤ 14
        if PlayingCards.suit(c) == Spade()
            suitoffset = 0
        elseif PlayingCards.suit(c) == Heart()
            suitoffset = 16
        elseif PlayingCards.suit(c) == Diamond()
            suitoffset = 32
        elseif PlayingCards.suit(c) == Club()
            suitoffset = 48
        end
        # 11 is Knight, so move up
        (12 <= r <= 13) && (r += 1)
        print(io, Char(0x1f0a0 + r + suitoffset))
    else
        # joker ? 
        print(io, Char(0x1f0e0))
    end
end

I think the suit selection here could be improved... :)

To be honest, the display in the Terminal of these fonts isn't brilliant, because they can be very small, particularly if it's really monospaced...

If there's some font substitution occurring, the card glyphs won't be monospaced (on my Mac it picks up the glyphs from DejaVu Sans):

This issue is used to trigger TagBot; feel free to unsubscribe.

If you haven't already, you should update your TagBot.yml to include issue comment triggers.
Please see this post on Discourse for instructions and more details.

If you'd like for me to do this for you, comment TagBot fix on this issue.
I'll open a PR within a few hours, please be patient!

Hi Charles,

I don't feel comfortable editing your code because I might change things you don't want changed (and I might introduce bugs). So I'll use this Issues section to make suggestions. First one is that I'd like to see a color function. Here's a quick way to implement that I think is consistent with your package design.

I'd like this feature because in solitaire games one often builds piles with alternating colors.

Thanks,
Ed

Add this:

export RedSuit, BlackSuit, color

"""
`color(C::Card)` returns `BlackSuit` if the card is a 
club or spade, and returns `RedSuit` is it's a heart or 
a diamond.
"""
function color(C::Card)
    return supertype(typeof(suit(C)))
end

Example:

julia> C = 5♠
5♠

julia> color(C)
BlackSuit

You can enter (say) the five of diamonds by typing 5+\diamondsuit+TAB and you get 5♢. All is well.

However, 5+\:diamonds:+TAB gives 5♦ which is not valid. Likewise for \heartsuit vs \:hearts:.

Interestingly, the black suits are ok: \clubsuit and \:clubs: give the same character (and likewise for spades).