diff --git a/proptools/clone.go b/proptools/clone.go
index d08a9db..7496584 100644
--- a/proptools/clone.go
+++ b/proptools/clone.go
@@ -91,27 +91,34 @@
 			}
 			fallthrough
 		case reflect.Ptr:
-			if srcFieldValue.Type().Elem().Kind() != reflect.Struct {
-				panic(fmt.Errorf("can't clone field %q: points to a non-struct",
-					field.Name))
-			}
-
 			if srcFieldValue.IsNil() {
 				dstFieldValue.Set(srcFieldValue)
 				break
 			}
 
-			if !dstFieldValue.IsNil() {
-				// Re-use the existing allocation.
-				CopyProperties(dstFieldValue.Elem(), srcFieldValue.Elem())
-				break
-			} else {
-				newValue := CloneProperties(srcFieldValue.Elem())
-				if dstFieldInterfaceValue.IsValid() {
-					dstFieldInterfaceValue.Set(newValue)
+			srcFieldValue := srcFieldValue.Elem()
+
+			switch srcFieldValue.Kind() {
+			case reflect.Struct:
+				if !dstFieldValue.IsNil() {
+					// Re-use the existing allocation.
+					CopyProperties(dstFieldValue.Elem(), srcFieldValue)
+					break
 				} else {
-					dstFieldValue.Set(newValue)
+					newValue := CloneProperties(srcFieldValue)
+					if dstFieldInterfaceValue.IsValid() {
+						dstFieldInterfaceValue.Set(newValue)
+					} else {
+						dstFieldValue.Set(newValue)
+					}
 				}
+			case reflect.Bool, reflect.String:
+				newValue := reflect.New(srcFieldValue.Type())
+				newValue.Elem().Set(srcFieldValue)
+				dstFieldValue.Set(newValue)
+			default:
+				panic(fmt.Errorf("can't clone field %q: points to a %s",
+					field.Name, srcFieldValue.Kind()))
 			}
 		default:
 			panic(fmt.Errorf("unexpected kind for property struct field %q: %s",
@@ -153,18 +160,19 @@
 			}
 			fallthrough
 		case reflect.Ptr:
-			// We leave the pointer intact and zero out the struct that's
-			// pointed to.
-			if fieldValue.Type().Elem().Kind() != reflect.Struct {
-				panic(fmt.Errorf("can't zero field %q: points to a non-struct",
-					field.Name))
+			switch fieldValue.Type().Elem().Kind() {
+			case reflect.Struct:
+				if fieldValue.IsNil() {
+					break
+				}
+				ZeroProperties(fieldValue.Elem())
+			case reflect.Bool, reflect.String:
+				fieldValue.Set(reflect.Zero(fieldValue.Type()))
+			default:
+				panic(fmt.Errorf("can't zero field %q: points to a %s",
+					field.Name, fieldValue.Elem().Kind()))
 			}
 
-			if fieldValue.IsNil() {
-				break
-			}
-
-			ZeroProperties(fieldValue.Elem())
 		default:
 			panic(fmt.Errorf("unexpected kind for property struct field %q: %s",
 				field.Name, fieldValue.Kind()))
@@ -217,21 +225,24 @@
 			dstFieldValue = newValue
 			fallthrough
 		case reflect.Ptr:
-			if srcFieldValue.Type().Elem().Kind() != reflect.Struct {
-				panic(fmt.Errorf("can't clone field %q: points to a non-struct",
-					field.Name))
+			switch srcFieldValue.Type().Elem().Kind() {
+			case reflect.Struct:
+				if srcFieldValue.IsNil() {
+					break
+				}
+				newValue := CloneEmptyProperties(srcFieldValue.Elem())
+				if dstFieldInterfaceValue.IsValid() {
+					dstFieldInterfaceValue.Set(newValue)
+				} else {
+					dstFieldValue.Set(newValue)
+				}
+			case reflect.Bool, reflect.String:
+				// Nothing
+			default:
+				panic(fmt.Errorf("can't clone empty field %q: points to a %s",
+					field.Name, srcFieldValue.Elem().Kind()))
 			}
 
-			if srcFieldValue.IsNil() {
-				break
-			}
-
-			newValue := CloneEmptyProperties(srcFieldValue.Elem())
-			if dstFieldInterfaceValue.IsValid() {
-				dstFieldInterfaceValue.Set(newValue)
-			} else {
-				dstFieldValue.Set(newValue)
-			}
 		default:
 			panic(fmt.Errorf("unexpected kind for property struct field %q: %s",
 				field.Name, srcFieldValue.Kind()))
diff --git a/proptools/clone_test.go b/proptools/clone_test.go
index b082543..f7460cf 100644
--- a/proptools/clone_test.go
+++ b/proptools/clone_test.go
@@ -71,6 +71,25 @@
 		out: &struct{ S []string }{},
 	},
 	{
+		// Clone pointer to bool
+		in: &struct{ B1, B2 *bool }{
+			B1: BoolPtr(true),
+			B2: BoolPtr(false),
+		},
+		out: &struct{ B1, B2 *bool }{
+			B1: BoolPtr(true),
+			B2: BoolPtr(false),
+		},
+	},
+	{
+		// Clone pointer to string
+		in: &struct{ S *string }{
+			S: StringPtr("string1"),
+		},
+		out: &struct{ S *string }{
+			S: StringPtr("string1"),
+		},
+	},
 	{
 		// Clone struct
 		in: &struct{ S struct{ S string } }{
@@ -201,6 +220,20 @@
 		out: &struct{ S []string }{},
 	},
 	{
+		// Clone pointer to bool
+		in: &struct{ B1, B2 *bool }{
+			B1: BoolPtr(true),
+			B2: BoolPtr(false),
+		},
+		out: &struct{ B1, B2 *bool }{},
+	},
+	{
+		// Clone pointer to string
+		in: &struct{ S *string }{
+			S: StringPtr("string1"),
+		},
+		out: &struct{ S *string }{},
+	},
 	{
 		// Clone struct
 		in: &struct{ S struct{ S string } }{
diff --git a/proptools/extend.go b/proptools/extend.go
index 241643b..d356419 100644
--- a/proptools/extend.go
+++ b/proptools/extend.go
@@ -29,8 +29,9 @@
 // An error returned by AppendProperties that applies to a specific property will be an
 // *ExtendPropertyError, and can have the property name and error extracted from it.
 //
-// The append operation is defined as appending string and slices of strings normally, OR-ing
-// bool values, and recursing into embedded structs, pointers to structs, and interfaces containing
+// The append operation is defined as appending strings, pointers to strings, and slices of
+// strings normally, OR-ing bool values, replacing non-nil pointers to booleans, and recursing into
+// embedded structs, pointers to structs, and interfaces containing
 // pointers to structs.  Appending the zero value of a property will always be a no-op.
 func AppendProperties(dst interface{}, src interface{}, filter ExtendPropertyFilterFunc) error {
 	return extendProperties(dst, src, filter, false)
@@ -46,8 +47,9 @@
 // An error returned by PrependProperties that applies to a specific property will be an
 // *ExtendPropertyError, and can have the property name and error extracted from it.
 //
-// The prepend operation is defined as prepending string and slices of strings normally, OR-ing
-// bool values, and recursing into embedded structs, pointers to structs, and interfaces containing
+// The prepend operation is defined as prepending strings, pointers to strings, and slices of
+// strings normally, OR-ing bool values, replacing non-nil pointers to booleans, and recursing into
+// embedded structs, pointers to structs, and interfaces containing
 // pointers to structs.  Prepending the zero value of a property will always be a no-op.
 func PrependProperties(dst interface{}, src interface{}, filter ExtendPropertyFilterFunc) error {
 	return extendProperties(dst, src, filter, true)
@@ -65,8 +67,9 @@
 // An error returned by AppendMatchingProperties that applies to a specific property will be an
 // *ExtendPropertyError, and can have the property name and error extracted from it.
 //
-// The append operation is defined as appending string and slices of strings normally, OR-ing
-// bool values, and recursing into embedded structs, pointers to structs, and interfaces containing
+// The append operation is defined as appending strings, pointers to strings, and slices of
+// strings normally, OR-ing bool values, replacing non-nil pointers to booleans, and recursing into
+// embedded structs, pointers to structs, and interfaces containing
 // pointers to structs.  Appending the zero value of a property will always be a no-op.
 func AppendMatchingProperties(dst []interface{}, src interface{},
 	filter ExtendPropertyFilterFunc) error {
@@ -85,8 +88,9 @@
 // An error returned by PrependProperties that applies to a specific property will be an
 // *ExtendPropertyError, and can have the property name and error extracted from it.
 //
-// The prepend operation is defined as prepending string and slices of strings normally, OR-ing
-// bool values, and recursing into embedded structs, pointers to structs, and interfaces containing
+// The prepend operation is defined as prepending strings, pointers to strings, and slices of
+// strings normally, OR-ing bool values, replacing non-nil pointers to booleans, and recursing into
+// embedded structs, pointers to structs, and interfaces containing
 // pointers to structs.  Prepending the zero value of a property will always be a no-op.
 func PrependMatchingProperties(dst []interface{}, src interface{},
 	filter ExtendPropertyFilterFunc) error {
@@ -213,6 +217,18 @@
 
 				fallthrough
 			case reflect.Ptr:
+				ptrKind := srcFieldValue.Type().Elem().Kind()
+				if ptrKind == reflect.Bool || ptrKind == reflect.String {
+					if srcFieldValue.Type() != dstFieldValue.Type() {
+						return extendPropertyErrorf(propertyName, "mismatched pointer types %s and %s",
+							dstFieldValue.Type(), srcFieldValue.Type())
+					}
+					break
+				} else if ptrKind != reflect.Struct {
+					return extendPropertyErrorf(propertyName, "pointer is a %s", ptrKind)
+				}
+
+				// Pointer to a struct
 				if dstFieldValue.IsNil() != srcFieldValue.IsNil() {
 					return extendPropertyErrorf(propertyName, "nilitude mismatch")
 				}
@@ -223,10 +239,6 @@
 				dstFieldValue = dstFieldValue.Elem()
 				srcFieldValue = srcFieldValue.Elem()
 
-				if srcFieldValue.Kind() != reflect.Struct || dstFieldValue.Kind() != reflect.Struct {
-					return extendPropertyErrorf(propertyName, "pointer not to a struct")
-				}
-
 				fallthrough
 			case reflect.Struct:
 				if sameTypes && dstFieldValue.Type() != srcFieldValue.Type() {
@@ -293,6 +305,34 @@
 					newSlice = reflect.AppendSlice(newSlice, srcFieldValue)
 				}
 				dstFieldValue.Set(newSlice)
+			case reflect.Ptr:
+				if srcFieldValue.IsNil() {
+					break
+				}
+
+				switch ptrKind := srcFieldValue.Type().Elem().Kind(); ptrKind {
+				case reflect.Bool:
+					if prepend {
+						if dstFieldValue.IsNil() {
+							dstFieldValue.Set(reflect.ValueOf(BoolPtr(srcFieldValue.Elem().Bool())))
+						}
+					} else {
+						// For append, replace the original value.
+						dstFieldValue.Set(reflect.ValueOf(BoolPtr(srcFieldValue.Elem().Bool())))
+					}
+				case reflect.String:
+					dstStr := ""
+					if !dstFieldValue.IsNil() {
+						dstStr = dstFieldValue.Elem().String()
+					}
+					if prepend {
+						dstFieldValue.Set(reflect.ValueOf(StringPtr(srcFieldValue.Elem().String() + dstStr)))
+					} else {
+						dstFieldValue.Set(reflect.ValueOf(StringPtr(dstStr + srcFieldValue.Elem().String())))
+					}
+				default:
+					panic(fmt.Errorf("unexpected pointer kind %s", ptrKind))
+				}
 			}
 		}
 		if !found {
diff --git a/proptools/extend_test.go b/proptools/extend_test.go
index a2482cc..35a1816 100644
--- a/proptools/extend_test.go
+++ b/proptools/extend_test.go
@@ -101,6 +101,114 @@
 		prepend: true,
 	},
 	{
+		// Append pointer to bool
+		in1: &struct{ B1, B2, B3, B4, B5, B6, B7, B8, B9 *bool }{
+			B1: BoolPtr(true),
+			B2: BoolPtr(false),
+			B3: nil,
+			B4: BoolPtr(true),
+			B5: BoolPtr(false),
+			B6: nil,
+			B7: BoolPtr(true),
+			B8: BoolPtr(false),
+			B9: nil,
+		},
+		in2: &struct{ B1, B2, B3, B4, B5, B6, B7, B8, B9 *bool }{
+			B1: nil,
+			B2: nil,
+			B3: nil,
+			B4: BoolPtr(true),
+			B5: BoolPtr(true),
+			B6: BoolPtr(true),
+			B7: BoolPtr(false),
+			B8: BoolPtr(false),
+			B9: BoolPtr(false),
+		},
+		out: &struct{ B1, B2, B3, B4, B5, B6, B7, B8, B9 *bool }{
+			B1: BoolPtr(true),
+			B2: BoolPtr(false),
+			B3: nil,
+			B4: BoolPtr(true),
+			B5: BoolPtr(true),
+			B6: BoolPtr(true),
+			B7: BoolPtr(false),
+			B8: BoolPtr(false),
+			B9: BoolPtr(false),
+		},
+	},
+	{
+		// Prepend pointer to bool
+		in1: &struct{ B1, B2, B3, B4, B5, B6, B7, B8, B9 *bool }{
+			B1: BoolPtr(true),
+			B2: BoolPtr(false),
+			B3: nil,
+			B4: BoolPtr(true),
+			B5: BoolPtr(false),
+			B6: nil,
+			B7: BoolPtr(true),
+			B8: BoolPtr(false),
+			B9: nil,
+		},
+		in2: &struct{ B1, B2, B3, B4, B5, B6, B7, B8, B9 *bool }{
+			B1: nil,
+			B2: nil,
+			B3: nil,
+			B4: BoolPtr(true),
+			B5: BoolPtr(true),
+			B6: BoolPtr(true),
+			B7: BoolPtr(false),
+			B8: BoolPtr(false),
+			B9: BoolPtr(false),
+		},
+		out: &struct{ B1, B2, B3, B4, B5, B6, B7, B8, B9 *bool }{
+			B1: BoolPtr(true),
+			B2: BoolPtr(false),
+			B3: nil,
+			B4: BoolPtr(true),
+			B5: BoolPtr(false),
+			B6: BoolPtr(true),
+			B7: BoolPtr(true),
+			B8: BoolPtr(false),
+			B9: BoolPtr(false),
+		},
+		prepend: true,
+	},
+	{
+		// Append pointer to strings
+		in1: &struct{ S1, S2, S3, S4 *string }{
+			S1: StringPtr("string1"),
+			S2: StringPtr("string2"),
+		},
+		in2: &struct{ S1, S2, S3, S4 *string }{
+			S1: StringPtr("string3"),
+			S3: StringPtr("string4"),
+		},
+		out: &struct{ S1, S2, S3, S4 *string }{
+			S1: StringPtr("string1string3"),
+			S2: StringPtr("string2"),
+			S3: StringPtr("string4"),
+			S4: nil,
+		},
+	},
+	{
+		// Prepend pointer to strings
+		in1: &struct{ S1, S2, S3, S4 *string }{
+			S1: StringPtr("string1"),
+			S2: StringPtr("string2"),
+		},
+		in2: &struct{ S1, S2, S3, S4 *string }{
+			S1: StringPtr("string3"),
+			S3: StringPtr("string4"),
+		},
+		out: &struct{ S1, S2, S3, S4 *string }{
+			S1: StringPtr("string3string1"),
+			S2: StringPtr("string2"),
+			S3: StringPtr("string4"),
+			S4: nil,
+		},
+		prepend: true,
+	},
+	{
 		// Append slice
 		in1: &struct{ S []string }{
 			S: []string{"string1"},
@@ -439,7 +547,7 @@
 		out: &struct{ S *[]string }{
 			S: &[]string{"string1"},
 		},
-		err: extendPropertyErrorf("s", "pointer not to a struct"),
+		err: extendPropertyErrorf("s", "pointer is a slice"),
 	},
 	{
 		// Error in nested struct
diff --git a/proptools/proptools.go b/proptools/proptools.go
index 79c4f6d..690d384 100644
--- a/proptools/proptools.go
+++ b/proptools/proptools.go
@@ -49,3 +49,31 @@
 
 	return false
 }
+
+// BoolPtr returns a pointer to a new bool containing the given value.
+func BoolPtr(b bool) *bool {
+	return &b
+}
+
+// StringPtr returns a pointer to a new string containing the given value.
+func StringPtr(s string) *string {
+	return &s
+}
+
+// Bool takes a pointer to a bool and returns true iff the pointer is non-nil and points to a true
+// value.
+func Bool(b *bool) bool {
+	if b != nil {
+		return *b
+	}
+	return false
+}
+
+// String takes a pointer to a string and returns the value of the string if the pointer is non-nil,
+// or an empty string.
+func String(s *string) string {
+	if s != nil {
+		return *s
+	}
+	return ""
+}
diff --git a/unpack.go b/unpack.go
index 445a8c6..64c65e4 100644
--- a/unpack.go
+++ b/unpack.go
@@ -161,15 +161,18 @@
 			}
 			fallthrough
 		case reflect.Ptr:
-			if fieldValue.IsNil() {
-				panic(fmt.Errorf("field %s contains a nil pointer",
-					field.Name))
-			}
-			fieldValue = fieldValue.Elem()
-			elemType := fieldValue.Type()
-			if elemType.Kind() != reflect.Struct {
-				panic(fmt.Errorf("field %s contains a non-struct pointer",
-					field.Name))
+			switch ptrKind := fieldValue.Type().Elem().Kind(); ptrKind {
+			case reflect.Struct:
+				if fieldValue.IsNil() {
+					panic(fmt.Errorf("field %s contains a nil pointer",
+						field.Name))
+				}
+				fieldValue = fieldValue.Elem()
+			case reflect.Bool, reflect.String:
+				// Nothing
+			default:
+				panic(fmt.Errorf("field %s contains a pointer to %s",
+					field.Name, ptrKind))
 			}
 
 		case reflect.Int, reflect.Uint:
@@ -225,9 +228,19 @@
 			newErrs = unpackString(fieldValue, packedProperty.property)
 		case reflect.Slice:
 			newErrs = unpackSlice(fieldValue, packedProperty.property)
-		case reflect.Ptr, reflect.Interface:
-			fieldValue = fieldValue.Elem()
-			fallthrough
+		case reflect.Ptr:
+			switch ptrKind := fieldValue.Type().Elem().Kind(); ptrKind {
+			case reflect.Bool:
+				newValue := reflect.New(fieldValue.Type().Elem())
+				newErrs = unpackBool(newValue.Elem(), packedProperty.property)
+				fieldValue.Set(newValue)
+			case reflect.String:
+				newValue := reflect.New(fieldValue.Type().Elem())
+				newErrs = unpackString(newValue.Elem(), packedProperty.property)
+				fieldValue.Set(newValue)
+			default:
+				panic(fmt.Errorf("unexpected pointer kind %s", ptrKind))
+			}
 		case reflect.Struct:
 			localFilterKey, localFilterValue := filterKey, filterValue
 			if k, v, err := HasFilter(field.Tag); err != nil {
@@ -248,6 +261,8 @@
 			}
 			newErrs = unpackStruct(propertyName+".", fieldValue,
 				packedProperty.property, propertyMap, localFilterKey, localFilterValue)
+		default:
+			panic(fmt.Errorf("unexpected kind %s", kind))
 		}
 		errs = append(errs, newErrs...)
 		if len(errs) >= maxErrors {
diff --git a/unpack_test.go b/unpack_test.go
index 0b31efc..77a57ec 100644
--- a/unpack_test.go
+++ b/unpack_test.go
@@ -33,6 +33,24 @@
 	{`
 		m {
 			name: "abc",
+			blank: "",
+		}
+		`,
+		struct {
+			Name  *string
+			Blank *string
+			Unset *string
+		}{
+			Name:  proptools.StringPtr("abc"),
+			Blank: proptools.StringPtr(""),
+			Unset: nil,
+		},
+		nil,
+	},
+
+	{`
+		m {
+			name: "abc",
 		}
 		`,
 		struct {
@@ -58,6 +76,24 @@
 
 	{`
 		m {
+			isGood: true,
+			isBad: false,
+		}
+		`,
+		struct {
+			IsGood *bool
+			IsBad  *bool
+			IsUgly *bool
+		}{
+			IsGood: proptools.BoolPtr(true),
+			IsBad:  proptools.BoolPtr(false),
+			IsUgly: nil,
+		},
+		nil,
+	},
+
+	{`
+		m {
 			stuff: ["asdf", "jkl;", "qwert",
 				"uiop", "bnm,"],
 			empty: []