We got her from PAWS in Lynwood on Friday March 24, 2023. The shelter told us she was 10 weeks old at that time, and she weighed about 18 pounds. Today just over three weeks later she weighs over 25 pounds! It’s been a whirlwind three weeks with a lot of hard work, a few setbacks, and so much change.

Week 1

Sleep

Week one was very tough. The first night we tried to have her sleep in our room which was a mistake. She had diarrhea on the floor several times and no one slept more than an hour or two. The following nights that week were a slight improvement, as we had decided to have her sleep in her crate in the living room while we took turns sleeping on the couch nearby. However she still had diarrhea for the first few days, and had to go out about every 90 minutes around the clock so again no one was really sleeping.

Behavior

The first week once she settled in she was biting absolutely everything, making no distinction between toys, furniture, shoes, toes, and hands. She was so rowdy and eager to play (in short puppy stretches) and explore our whole space, but we blocked off the top floor to give the cats some refuge. She was also nervous about going down the stairs to go outside, so we had to carry her the first couple of days of potty training.

On the subject of potty training, week one was definitely hardest but overall has not been too bad. During the day we took her out every hour, always after meals and play sessions as well. She did have a few accidents in the house but learned quickly that she was supposed to go outside. The hardest part of potty training was definitely the diarrhea, but by the end of week one that had started to clear up.

Since day one we have been working on her training. I love dogs but being around untrained, poorly behaved dogs is a chore at best. No one thinks your out of control dog is as cute as you do. This first week we were finding training tips online on Reddit, Youtube, and Instagram. She came to us knowing how to sit, and for this first week that was good enough in terms of commands. The main thing we wanted to work with her on at this point was biting. She was biting us quite a lot so we started to interrupt and redirect that behavior whenever she started.

Nora also came to us exhibiting a kind of aggressive over-excitement behavior, mostly when we were outside on the leash. She would suddenly go from normal puppy biting to growly and lunging in a flash, which we really wanted to get ahead of.

Broken Tooth

Our big setback week one was a broken tooth. She was very eager to play tug, which is one of my favorite games to play with a dog. So we were playing tug with a rope toy (in a way I didn’t think was too hard) and suddenly the rope came free from her mouth with snap and a small yelp of surprise. I heard a piece of the tooth hit the floor or wall, and immediately ran after her to see if she was OK. She seemed alright, but later that night I notices some signs of pain and so the next day the vet had a look and decided the broken tooth (her top right canine) had better be extracted, which it was, that same day (Saturday).

Week 2

Sleep

For most of this week we were taking turns sleeping on the couch next to the crate. She was sleeping much better though the night but still had to go out in the middle of the night at least once.

Puppy Class

On Monday of week two Nora attended her first of six weekly ‘puppy kindergarten’ classes. She had a great time playing with the other dogs:

Her prime socialization period is winding down in the next few weeks so we wanted to get her around other puppys to learn good manners when playing. We also learned some great tips on training her not to jump on guests as well as basic commands, I really can’t recommend a puppy class highly enough.

Broken Tooth recovery

The hardest part about having her tooth extracted was that during recovery she wasn’t supposed to have any chew toys. At first the vet had asked for a complete ban on chewing but that just wasn’t possible. She wanted to chew everything she could reach, to the point where every time we left the house to walk her she would find the first stick she could grab and just sit down to chew it. When she was in the house she would go after feet, furniture, the bars of her crate etc. We did make it through most of week two with her only having access to plush chew toys.

Week 3

Solo Dog Duty

This week Harmony was away from Wednesday to Sunday, meaning I’d have to manage Nora and the cats on my own. By this time we had made enough progress that I wasn’t too worried, though I was a little apprehensive about finding enough time for sleep and work. She ended up sticking to the 11-7 sleep schedule fairly well, although on most mornings the cats woke up around 5:30 for their breakfast, which woke Nora up, which meant everybody was up 😴

Sleep

Our current sleeping arrangement has her sleeping in her crate from 11:00 PM to 7:00 AM, which she can usually do without any issues. Occasionally she wakes up around 5:00 and needs to go out, but if she goes right back into her crate she’ll typically fall back asleep until the designated wake up time. My own sleep situation during this time was not great, between her and the cats and me being on my own I was only sleeping maybe five or six hours per night for most of this week.

Broken Tooth Recovery

By the middle of this week I had broken down and we were giving her some chewing time on her softer chews. I was checking her gums every day and she seemed to be healing very well, and by the end of the week her two week recovery period had passed. She back to eating kibble, chewing on digestible chew toys, and playing some (gentle) tug in the living room. She was so happy to be able to chew again! Her adult teeth will be coming in over the next couple of months, so we’ll have to keep redirecting her chewing to the proper outlets (squeak toys and beef tendon are her favorites).

Personality

It feels like her personality is really starting to come through, and she is such a fun dog! She wants to meet everyone she sees when we go out walking, dogs and humans. We are working on her greeting people respectfully but when we run in to strangers outside she gets too excited.

When we are inside and free of distractions her training is going great, though transferring that to other settings and with distractions is not really in the cards yet. Sometimes inside though she can be very willful and wants to ignore commands, but I’ve found that if I wait her out she will eventually comply.

She doesn’t like cuddling, or getting on furniture. In fact she won’t even sleep on the rug, when she goes down to sleep at night she always moves under the table on the bamboo floor before I put her in her crate. But that’s not to say she ignores us, when she is out of her crate she is constantly by our sides and if we leave her downstairs to get something upstairs she will often whine and bark and run around until we come back down.

Puppy Class

Her first week of puppy class she got to play in a milieu of all the puppys, but now by week three she is too big for most of them. She got segmented off with another large pup last night, but unfortunately the two of them did not get along well.

To Be Continued 🐶

I guess we’re dog people now. Life with Nora has been challenging, and rewarding; sometimes fun, sometimes boring; constantly changing and I can’t wait to see what’s next!

data List a = Nil | Cons a (List a)

newtype ListC a = ListC {unList :: forall r. r -> (a -> r -> r) -> r}

Just like MaybeC, ListC is a funciton that takes a default value and another function. In the case of an empty list, it returns the default value. To understand the recursive (non-empty) case it is helpful to note the similarity between the type of ListC and the type of foldr on regular lists, and then to see how cons is implemented for Church lists:

foldr :: (a -> r -> r) -> r -> [a] -> r

In fact, the types of foldr and ListC are so similar because Church encoded lists are exactly functions which fold over the lists they encode. To see how, observe the cons function given here:

-- nil is a fold that does nothing but return the zero value supplied to it
nil :: ListC a
nil = ListC $ \z f -> z

-- cons take an element to add and a list, and build a new function which
-- folds over the new (longer) list
cons :: a -> ListC a -> ListC a
cons head (ListC tail) = ListC $ \z f -> head `f` (tail z f)

To give a concrete example, let’s look at the list [1, 2] and use some equational reasoning to figure out how its Church encoding works.

-- Ordinary representation, then with explicit (:) calls
list :: [Int]
list = [1, 2]
     -- With explicit constructors:
list = 1 : (2 : [])

-- Then the Church encoding, using substitution to expand the definitions
-- newtype wrapping and unwrapping removed for clarity
church :: ListC Int
church = 1 `cons` (2 `cons` nil)
       -- using the definition of cons:
       = 1 `cons` (\z f -> 2 `f` (nil z f))
       -- by def. of nil, with capture avoiding substitution:
       = 1 `cons` (\z f -> 2 `f` ((\z' f' -> z') z f))
       -- by applying the inner lambda:
       = 1 `cons` (\z f -> 2 `f` z)
       -- by def. of cons:
       = \z f -> 1 `f` ((\z' f' -> 2 `f'` z') z f
       -- by applying the inner lambda:
church = \z f -> 1 `f` (2 `f` z)

As the last line shows, the Church encoded version is a function which folds over the list from the right.

And we can observe the parallels between these constructors and the definition of the foldr function for lists in the Prelude:

foldr k z = go
        where
          go []     = z           --nil
          go (y:ys) = y `k` go ys --cons

So if we want to define the Foldable instance for ListC, we need only define foldr as follows:

instance Foldable ListC where
    foldr f z (ListC l) = l z f

-- and a couple of useful instances follow from that directly:

instance Functor ListC where
    fmap f = foldr (cons . f) nil

instance Show a => Show (ListC a) 
    show = foldr (\head tail -> show head ++ "," ++ tail) "End"

Defining Nat

Having seen how ListC works to encode a recursive type, we can define our first primitive type (rather than a type constructor like ListC or MaybeC), NatC. As usual, we’ll look at the (recursive) ADT and the Church encoding side by side:

data Nat = Zero | Succ Nat

newtype NatC = NatC {unNat :: forall r. r -> (r -> r) -> r}

This looks exactly like the ListC type signature, but missing the type that goes inside the list. Looking at the constructors for NatC:

zero :: NatC
zero = NatC $ \x f -> x

succ :: NatC -> NatC
succ (NatC n) = NatC $ \x f -> f (n x f) 

So zero applies the function f to x zero times, succ zero applies the function f to x one time, and so on. This can be directly shown be equational reasoning similar to the example of the cons function above.

To define the sum of two Church numerals, use one to apply succ to the other repeatedly, as follows:

(+) :: NatC -> NatC -> NatC
(NatC n) + m = n m succ

And multiplication can be defined similarly, in terms of addition:

(*) :: NatC -> NatC -> NatC
(NatC n) * m = n zero (+m)

Which can both be used to give Nat instances of Monoid, as necessary.

One last note is the interesting parallel between ListC and NatC. Observe their types:

newtype ListC a = ListC {unList :: forall r. r -> (a -> r -> r) -> r}

newtype NatC = NatC {unNat :: forall r. r -> (r -> r) -> r}

The only difference is that ListC has a type parameter a where NatC does not. Indeed NatC can be defined in terms of ListC by stating:

newtype NatC = ListC ()

Where we can then reuse some of the machinery for ListC to define operations on NatC, using concatenation of lists for addition, fmap and concatenation for multiplication, etc. Especially challenging is the definition of tail for ListC or pred for NatC.

The set of lambda expressions, Λ, can be defined inductively:

1. If x is a variable, then x ∈ Λ
2. If x is a variable and M ∈ Λ, then (λx.M) ∈ Λ
3. If M, N ∈ Λ, then (M N) ∈ Λ

Practical programming languages almost always define data primitives and function primitives, but lambda calculus provides only unnamed functions. The Church encoding is one way of defining data types in lambda calculus, and this post will explore what it means to treat functions as data with the Church encoding in Haskell.

The first Church encoded type that really clicked for me was Maybe. Starting with Maybe is a bit of a cop out, because it’s only useful if you have some other data to wrap in it, but bear with me!

Maybe is given here with its usual algebraic data type notation and its corresponding Church-encoding:

-- As defined in the Prelude:
data Maybe a = Nothing | Just a

-- And an equivalent type, represented as a function:
newtype MaybeC a = MaybeC { runMaybe :: forall r. r -> (a -> r) -> r }

From the definition of Maybe we know that Maybe a is either wrapping an a or it’s nothing. Inspecting the type of MaybeC the intuition is that it takes a function f :: (a -> r) and a default value, and returns a value of r, either by applying f to the wrapped a, or returning the default. This is possible without knowledge of the type r, thus the universal quantification. The signature again, with the parts labelled:

--                       output
--                 f       |
--      default    |       |
--        |        |       |
forall r. r -> (a -> r) -> r

Translating this intuition into Haskell gives the data constructors:

-- When we do have a value, apply the given function to it
just :: a -> MaybeC a
just val = MaybeC $ \_ f -> f val

-- In the case where we have no value to work with, return the default
nothing :: MaybeC a
nothing = MaybeC $ \x _ -> x

And all of the usual instances for Maybe can be defined for MaybeC as well. For playing with this type in GHCi it is especially useful to have an instance of Show (it is also useful to remember to enable RankNTypes to get it to compile). Instances for Show and Functor can be defined as follows:

instance Show a => Show (MaybeC a) where
    show (MaybeC m) = m "Empty" (\x -> "Contains: " ++ show x)

instance Functor MaybeC where
    fmap f (MaybeC m) = m nothing (just . f)

The Show instance provides a good example of how to use a MaybeC value by passing in a function and a default value. Here the default is the string “Empty”, and the the function prints the value insdie the MaybeC otherwise.

In order to prove that Maybe and MaybeC are ismorphic, we first write the functions that map between them:

churchToMaybe :: MaybeC a -> Maybe a
churchToMaybe (MaybeC m) = m Nothing Just

-- Going in the other direction, note that this function can also be
-- written by slightly rearranging the arguments to `maybe` in Data.Maybe
maybeToChurch :: Maybe a -> MaybeC a
maybeToChurch Nothing = nothing
maybeToChurch (Just x) = just x

Isomorphism further requires that those functions are mutually inverse. That is:

churchToMaybe . maybeToChurch = id
-- AND that
maybeToChurch . churchToMaybe = id

Which can be proved by equational reasoning, but I’ll not write that out here. The next installment will introduce the Church numerals, and Church encoded lists, and then we can really start to use Church encoded data for something interesting!