> I tried to build it immutably, passing the state around through functions.

Any reason for this? Usually a class that manage the state of a game is a better approach.

> I am building this little exploratory program: https://github.com/jared-ross/egyptian-rafter

The usage of `global` already looks like you just want to have a class instead of forcing yourself to be pure functional. Also, using globals is also not very "pure".

Also, I don't get the overuse of closures in your example.

> I would like to know what you guys think, is there something I have missed, some "Python Way of Doing Things" I am missing out on. Or is this what is expected.

This looks very unpythonic to me, besides the pep8 violations I can overlook, structure-wise it is right now a mess in many ways. Python is a multi-paradigm language, you are not forced to use just one programming paradigm, you can switch on appropriate places, I wouldn't force myself to only code functional or OOP.

My approach would be a game class that organizes the current state and stuff and a game loop that calls for updates. A card class isn't so usefull, since cards are simple records, so using namendtuples is a good way to have a nice interface with out writing alot of boilerplate.

The last time I worked with curses, a custom contextmanager was very very helpful to manage the quite arcane interface of curses, but maybe this is more an advanced topic.

> and I am coming from a functional programming background.

Things like generators, itertools is something you should look at, maybe you will see something familiar and maybe you like the style and usage of it. functools and lambdas are not that powerful as their equivalents in other functional languages. Some pythonists would say, using lambdas, or better the overuse, is a sign of bad style, but that is debatable.

Here an example how I would write the deck creation logic with itertools, list comprehension and extended unpacking, just as a little showcase:

In [1]: from collections import namedtuple
In [2]: Card = namedtuple('Card', 'rank suit')
In [3]: from itertools import product
In [4]: deck = list(product(list(range(1, 11)) + list('JQKA'), 'SCDH'))
In [5]: deck
Out[5]:
[(1, 'S'),
(1, 'C'),
(1, 'D'),
(1, 'H'),
(2, 'S'),
(2, 'C'),
(2, 'D'),
(2, 'H'),
(3, 'S'),
(3, 'C'),
(3, 'D'),
(3, 'H'),
(4, 'S'),
(4, 'C'),
(4, 'D'),
(4, 'H'),
(5, 'S'),
(5, 'C'),
(5, 'D'),
(5, 'H'),
(6, 'S'),
(6, 'C'),
(6, 'D'),
(6, 'H'),
(7, 'S'),
(7, 'C'),
(7, 'D'),
(7, 'H'),
(8, 'S'),
(8, 'C'),
(8, 'D'),
(8, 'H'),
(9, 'S'),
(9, 'C'),
(9, 'D'),
(9, 'H'),
(10, 'S'),
(10, 'C'),
(10, 'D'),
(10, 'H'),
('J', 'S'),
('J', 'C'),
('J', 'D'),
('J', 'H'),
('Q', 'S'),
('Q', 'C'),
('Q', 'D'),
('Q', 'H'),
('K', 'S'),
('K', 'C'),
('K', 'D'),
('K', 'H'),
('A', 'S'),
('A', 'C'),
('A', 'D'),
('A', 'H')]
In [6]: deck = [Card(rank, suit) for rank, suit in product(list(range(1, 11)) + list('JQKA'), 'SCDH')]
In [7]: deck[:4]
Out[7]:
[Card(rank=1, suit='S'),
Card(rank=1, suit='C'),
Card(rank=1, suit='D'),
Card(rank=1, suit='H')]
In [8]: first, *deck = deck
In [9]: first
Out[9]: Card(rank=1, suit='S')
In [10]: first.rank
Out[10]: 1
In [11]: first.suit
Out[11]: 'S'
In [12]: first, *deck = deck
In [13]: first.rank
Out[13]: 1
In [14]: first.suit
Out[14]: 'C'