diff --git a/tests/YGFloatOptionalTest.cpp b/tests/YGFloatOptionalTest.cpp
index 38c7ebb3..3e231723 100644
--- a/tests/YGFloatOptionalTest.cpp
+++ b/tests/YGFloatOptionalTest.cpp
@@ -17,10 +17,11 @@ constexpr auto positive = YGFloatOptional{1234.5f};
 constexpr auto negative = YGFloatOptional{-9876.5f};
 
 TEST(YGFloatOptional, value) {
-  ASSERT_EQ(zero.getValue(), 0.0f);
-  ASSERT_EQ(one.getValue(), 1.0f);
-  ASSERT_EQ(positive.getValue(), 1234.5f);
-  ASSERT_EQ(negative.getValue(), -9876.5f);
+  ASSERT_TRUE(YGFloatIsUndefined(empty.unwrap()));
+  ASSERT_EQ(zero.unwrap(), 0.0f);
+  ASSERT_EQ(one.unwrap(), 1.0f);
+  ASSERT_EQ(positive.unwrap(), 1234.5f);
+  ASSERT_EQ(negative.unwrap(), -9876.5f);
 
   ASSERT_TRUE(empty.isUndefined());
   ASSERT_FALSE(zero.isUndefined());
@@ -46,11 +47,11 @@ TEST(YGFloatOptional, equality) {
   ASSERT_FALSE(one == positive);
 
   ASSERT_TRUE(positive == positive);
-  ASSERT_TRUE(positive == positive.getValue());
+  ASSERT_TRUE(positive == positive.unwrap());
   ASSERT_FALSE(positive == one);
 
   ASSERT_TRUE(negative == negative);
-  ASSERT_TRUE(negative == negative.getValue());
+  ASSERT_TRUE(negative == negative.unwrap());
   ASSERT_FALSE(negative == zero);
 }
 
@@ -71,11 +72,11 @@ TEST(YGFloatOptional, inequality) {
   ASSERT_TRUE(one != positive);
 
   ASSERT_FALSE(positive != positive);
-  ASSERT_FALSE(positive != positive.getValue());
+  ASSERT_FALSE(positive != positive.unwrap());
   ASSERT_TRUE(positive != one);
 
   ASSERT_FALSE(negative != negative);
-  ASSERT_FALSE(negative != negative.getValue());
+  ASSERT_FALSE(negative != negative.unwrap());
   ASSERT_TRUE(negative != zero);
 }
 
@@ -180,8 +181,8 @@ TEST(YGFloatOptional, less_than_equals) {
 }
 
 TEST(YGFloatOptional, addition) {
-  auto n = negative.getValue();
-  auto p = positive.getValue();
+  auto n = negative.unwrap();
+  auto p = positive.unwrap();
 
   ASSERT_EQ(zero + one, one);
   ASSERT_EQ(negative + positive, YGFloatOptional{n + p});
diff --git a/yoga/Utils.cpp b/yoga/Utils.cpp
index 331cb660..2035fe00 100644
--- a/yoga/Utils.cpp
+++ b/yoga/Utils.cpp
@@ -55,11 +55,12 @@ float YGFloatSanitize(const float val) {
   return yoga::isUndefined(val) ? 0 : val;
 }
 
-YGFloatOptional YGFloatOptionalMax(
-    const YGFloatOptional& op1,
-    const YGFloatOptional& op2) {
-  if (!op1.isUndefined() && !op2.isUndefined()) {
-    return op1.getValue() > op2.getValue() ? op1 : op2;
+YGFloatOptional YGFloatOptionalMax(YGFloatOptional op1, YGFloatOptional op2) {
+  if (op1 >= op2) {
+    return op1;
+  }
+  if (op2 > op1) {
+    return op2;
   }
   return op1.isUndefined() ? op2 : op1;
 }
diff --git a/yoga/Utils.h b/yoga/Utils.h
index e5e20ba3..9ea7a738 100644
--- a/yoga/Utils.h
+++ b/yoga/Utils.h
@@ -60,8 +60,8 @@ bool YGFloatsEqual(const float a, const float b);
 float YGFloatMax(const float a, const float b);
 
 YGFloatOptional YGFloatOptionalMax(
-    const YGFloatOptional& op1,
-    const YGFloatOptional& op2);
+    const YGFloatOptional op1,
+    const YGFloatOptional op2);
 
 float YGFloatMin(const float a, const float b);
 
diff --git a/yoga/YGFloatOptional.cpp b/yoga/YGFloatOptional.cpp
index 0bf89f29..d202d4d5 100644
--- a/yoga/YGFloatOptional.cpp
+++ b/yoga/YGFloatOptional.cpp
@@ -12,15 +12,6 @@
 
 using namespace facebook;
 
-float YGFloatOptional::getValue() const {
-  if (isUndefined()) {
-    // Abort, accessing a value of an undefined float optional
-    std::cerr << "Tried to get value of an undefined YGFloatOptional\n";
-    std::exit(EXIT_FAILURE);
-  }
-  return value_;
-}
-
 bool YGFloatOptional::operator==(YGFloatOptional op) const {
   return value_ == op.value_ || (isUndefined() && op.isUndefined());
 }
diff --git a/yoga/YGFloatOptional.h b/yoga/YGFloatOptional.h
index 56bc8557..b4974798 100644
--- a/yoga/YGFloatOptional.h
+++ b/yoga/YGFloatOptional.h
@@ -17,11 +17,6 @@ struct YGFloatOptional {
   explicit constexpr YGFloatOptional(float value) : value_(value) {}
   constexpr YGFloatOptional() = default;
 
-  // Program will terminate if the value of an undefined is accessed. Please
-  // make sure to check if the optional is defined before calling this function.
-  // To check if float optional is defined, use `isUndefined()`.
-  float getValue() const;
-
   // returns the wrapped value, or a value x with YGIsUndefined(x) == true
   float unwrap() const {
     return value_;
diff --git a/yoga/YGNode.cpp b/yoga/YGNode.cpp
index d930c51a..3da72cb6 100644
--- a/yoga/YGNode.cpp
+++ b/yoga/YGNode.cpp
@@ -211,7 +211,7 @@ YGFloatOptional YGNode::relativePosition(
 
   YGFloatOptional trailingPosition = getTrailingPosition(axis, axisSize);
   if (!trailingPosition.isUndefined()) {
-    trailingPosition = YGFloatOptional{-1 * trailingPosition.getValue()};
+    trailingPosition = YGFloatOptional{-1 * trailingPosition.unwrap()};
   }
   return trailingPosition;
 }
@@ -302,7 +302,7 @@ YGValue YGNode::resolveFlexBasisPtr() const {
   if (flexBasis.unit != YGUnitAuto && flexBasis.unit != YGUnitUndefined) {
     return flexBasis;
   }
-  if (!style_.flex.isUndefined() && style_.flex.getValue() > 0.0f) {
+  if (!style_.flex.isUndefined() && style_.flex.unwrap() > 0.0f) {
     return config_->useWebDefaults ? YGValueAuto : YGValueZero;
   }
   return YGValueAuto;
@@ -393,10 +393,10 @@ float YGNode::resolveFlexGrow() {
     return 0.0;
   }
   if (!style_.flexGrow.isUndefined()) {
-    return style_.flexGrow.getValue();
+    return style_.flexGrow.unwrap();
   }
-  if (!style_.flex.isUndefined() && style_.flex.getValue() > 0.0f) {
-    return style_.flex.getValue();
+  if (!style_.flex.isUndefined() && style_.flex.unwrap() > 0.0f) {
+    return style_.flex.unwrap();
   }
   return kDefaultFlexGrow;
 }
@@ -406,11 +406,11 @@ float YGNode::resolveFlexShrink() {
     return 0.0;
   }
   if (!style_.flexShrink.isUndefined()) {
-    return style_.flexShrink.getValue();
+    return style_.flexShrink.unwrap();
   }
   if (!config_->useWebDefaults && !style_.flex.isUndefined() &&
-      style_.flex.getValue() < 0.0f) {
-    return -style_.flex.getValue();
+      style_.flex.unwrap() < 0.0f) {
+    return -style_.flex.unwrap();
   }
   return config_->useWebDefaults ? kWebDefaultFlexShrink : kDefaultFlexShrink;
 }
@@ -455,7 +455,7 @@ YGFloatOptional YGNode::getLeadingPadding(
       YGResolveValue(style_.padding[YGEdgeStart], widthSize);
   if (YGFlexDirectionIsRow(axis) &&
       style_.padding[YGEdgeStart].unit != YGUnitUndefined &&
-      !paddingEdgeStart.isUndefined() && paddingEdgeStart.getValue() >= 0.0f) {
+      !paddingEdgeStart.isUndefined() && paddingEdgeStart.unwrap() >= 0.0f) {
     return paddingEdgeStart;
   }
 
@@ -471,7 +471,7 @@ YGFloatOptional YGNode::getTrailingPadding(
   if (YGFlexDirectionIsRow(axis) &&
       style_.padding[YGEdgeEnd].unit != YGUnitUndefined &&
       !YGResolveValue(style_.padding[YGEdgeEnd], widthSize).isUndefined() &&
-      YGResolveValue(style_.padding[YGEdgeEnd], widthSize).getValue() >= 0.0f) {
+      YGResolveValue(style_.padding[YGEdgeEnd], widthSize).unwrap() >= 0.0f) {
     return YGResolveValue(style_.padding[YGEdgeEnd], widthSize);
   }
 
diff --git a/yoga/YGNodePrint.cpp b/yoga/YGNodePrint.cpp
index 541a6fef..8eb33f93 100644
--- a/yoga/YGNodePrint.cpp
+++ b/yoga/YGNodePrint.cpp
@@ -43,7 +43,7 @@ static void appendFloatOptionalIfDefined(
     const string key,
     const YGFloatOptional num) {
   if (!num.isUndefined()) {
-    appendFormatedString(base, "%s: %g; ", key.c_str(), num.getValue());
+    appendFormatedString(base, "%s: %g; ", key.c_str(), num.unwrap());
   }
 }
 
diff --git a/yoga/YGStyle.cpp b/yoga/YGStyle.cpp
index bc90463e..78df8b01 100644
--- a/yoga/YGStyle.cpp
+++ b/yoga/YGStyle.cpp
@@ -28,26 +28,26 @@ bool YGStyle::operator==(const YGStyle& style) {
   if (areNonFloatValuesEqual && !flex.isUndefined() &&
       !style.flex.isUndefined()) {
     areNonFloatValuesEqual =
-        areNonFloatValuesEqual && flex.getValue() == style.flex.getValue();
+        areNonFloatValuesEqual && flex == style.flex;
   }
 
   areNonFloatValuesEqual = areNonFloatValuesEqual &&
       flexGrow.isUndefined() == style.flexGrow.isUndefined();
   if (areNonFloatValuesEqual && !flexGrow.isUndefined()) {
     areNonFloatValuesEqual = areNonFloatValuesEqual &&
-        flexGrow.getValue() == style.flexGrow.getValue();
+        flexGrow == style.flexGrow;
   }
 
   areNonFloatValuesEqual = areNonFloatValuesEqual &&
       flexShrink.isUndefined() == style.flexShrink.isUndefined();
   if (areNonFloatValuesEqual && !style.flexShrink.isUndefined()) {
     areNonFloatValuesEqual = areNonFloatValuesEqual &&
-        flexShrink.getValue() == style.flexShrink.getValue();
+        flexShrink == style.flexShrink;
   }
 
   if (!(aspectRatio.isUndefined() && style.aspectRatio.isUndefined())) {
     areNonFloatValuesEqual = areNonFloatValuesEqual &&
-        aspectRatio.getValue() == style.aspectRatio.getValue();
+        aspectRatio == style.aspectRatio;
   }
 
   return areNonFloatValuesEqual;
diff --git a/yoga/Yoga.cpp b/yoga/Yoga.cpp
index 8db18e9e..abc4ae74 100644
--- a/yoga/Yoga.cpp
+++ b/yoga/Yoga.cpp
@@ -581,14 +581,14 @@ void YGNodeCopyStyle(const YGNodeRef dstNode, const YGNodeRef srcNode) {
 float YGNodeStyleGetFlexGrow(const YGNodeRef node) {
   return node->getStyle().flexGrow.isUndefined()
       ? kDefaultFlexGrow
-      : node->getStyle().flexGrow.getValue();
+      : node->getStyle().flexGrow.unwrap();
 }
 
 float YGNodeStyleGetFlexShrink(const YGNodeRef node) {
   return node->getStyle().flexShrink.isUndefined()
       ? (node->getConfig()->useWebDefaults ? kWebDefaultFlexShrink
                                            : kDefaultFlexShrink)
-      : node->getStyle().flexShrink.getValue();
+      : node->getStyle().flexShrink.unwrap();
 }
 
 namespace {
@@ -857,7 +857,7 @@ void YGNodeStyleSetFlex(const YGNodeRef node, const float flex) {
 // TODO(T26792433): Change the API to accept YGFloatOptional.
 float YGNodeStyleGetFlex(const YGNodeRef node) {
   return node->getStyle().flex.isUndefined() ? YGUndefined
-                                             : node->getStyle().flex.getValue();
+                                             : node->getStyle().flex.unwrap();
 }
 
 // TODO(T26792433): Change the API to accept YGFloatOptional.
@@ -959,7 +959,7 @@ float YGNodeStyleGetBorder(const YGNodeRef node, const YGEdge edge) {
 // TODO(T26792433): Change the API to accept YGFloatOptional.
 float YGNodeStyleGetAspectRatio(const YGNodeRef node) {
   const YGFloatOptional op = node->getStyle().aspectRatio;
-  return op.isUndefined() ? YGUndefined : op.getValue();
+  return op.isUndefined() ? YGUndefined : op.unwrap();
 }
 
 // TODO(T26792433): Change the API to accept YGFloatOptional.
@@ -1229,11 +1229,11 @@ static YGFloatOptional YGNodeBoundAxisWithinMinAndMax(
         node->getStyle().maxDimensions[YGDimensionWidth], axisSize);
   }
 
-  if (!max.isUndefined() && max.getValue() >= 0 && value > max.getValue()) {
+  if (!max.isUndefined() && max.unwrap() >= 0 && value > max.unwrap()) {
     return max;
   }
 
-  if (!min.isUndefined() && min.getValue() >= 0 && value < min.getValue()) {
+  if (!min.isUndefined() && min.unwrap() >= 0 && value < min.unwrap()) {
     return min;
   }
 
@@ -1277,14 +1277,14 @@ static void YGConstrainMaxSizeForMode(
   switch (*mode) {
     case YGMeasureModeExactly:
     case YGMeasureModeAtMost:
-      *size = (maxSize.isUndefined() || *size < maxSize.getValue())
+      *size = (maxSize.isUndefined() || *size < maxSize.unwrap())
           ? *size
-          : maxSize.getValue();
+          : maxSize.unwrap();
       break;
     case YGMeasureModeUndefined:
       if (!maxSize.isUndefined()) {
         *mode = YGMeasureModeAtMost;
-        *size = maxSize.getValue();
+        *size = maxSize.unwrap();
       }
       break;
   }
@@ -1399,13 +1399,13 @@ static void YGNodeComputeFlexBasisForChild(
     if (!child->getStyle().aspectRatio.isUndefined()) {
       if (!isMainAxisRow && childWidthMeasureMode == YGMeasureModeExactly) {
         childHeight = marginColumn +
-            (childWidth - marginRow) / child->getStyle().aspectRatio.getValue();
+            (childWidth - marginRow) / child->getStyle().aspectRatio.unwrap();
         childHeightMeasureMode = YGMeasureModeExactly;
       } else if (
           isMainAxisRow && childHeightMeasureMode == YGMeasureModeExactly) {
         childWidth = marginRow +
             (childHeight - marginColumn) *
-                child->getStyle().aspectRatio.getValue();
+                child->getStyle().aspectRatio.unwrap();
         childWidthMeasureMode = YGMeasureModeExactly;
       }
     }
@@ -1425,7 +1425,7 @@ static void YGNodeComputeFlexBasisForChild(
       childWidthMeasureMode = YGMeasureModeExactly;
       if (!child->getStyle().aspectRatio.isUndefined()) {
         childHeight =
-            (childWidth - marginRow) / child->getStyle().aspectRatio.getValue();
+            (childWidth - marginRow) / child->getStyle().aspectRatio.unwrap();
         childHeightMeasureMode = YGMeasureModeExactly;
       }
     }
@@ -1442,7 +1442,7 @@ static void YGNodeComputeFlexBasisForChild(
 
       if (!child->getStyle().aspectRatio.isUndefined()) {
         childWidth = (childHeight - marginColumn) *
-            child->getStyle().aspectRatio.getValue();
+            child->getStyle().aspectRatio.unwrap();
         childWidthMeasureMode = YGMeasureModeExactly;
       }
     }
@@ -1557,10 +1557,10 @@ static void YGNodeAbsoluteLayoutChild(
       if (YGFloatIsUndefined(childWidth)) {
         childWidth = marginRow +
             (childHeight - marginColumn) *
-                child->getStyle().aspectRatio.getValue();
+                child->getStyle().aspectRatio.unwrap();
       } else if (YGFloatIsUndefined(childHeight)) {
         childHeight = marginColumn +
-            (childWidth - marginRow) / child->getStyle().aspectRatio.getValue();
+            (childWidth - marginRow) / child->getStyle().aspectRatio.unwrap();
       }
     }
   }
@@ -1886,14 +1886,14 @@ static float YGNodeCalculateAvailableInnerDim(
         YGResolveValue(node->getStyle().minDimensions[dimension], ownerDim);
     const float minInnerDim = minDimensionOptional.isUndefined()
         ? 0.0f
-        : minDimensionOptional.getValue() - paddingAndBorder;
+        : minDimensionOptional.unwrap() - paddingAndBorder;
 
     const YGFloatOptional maxDimensionOptional =
         YGResolveValue(node->getStyle().maxDimensions[dimension], ownerDim);
 
     const float maxInnerDim = maxDimensionOptional.isUndefined()
         ? FLT_MAX
-        : maxDimensionOptional.getValue() - paddingAndBorder;
+        : maxDimensionOptional.unwrap() - paddingAndBorder;
     availableInnerDim =
         YGFloatMax(YGFloatMin(availableInnerDim, maxInnerDim), minInnerDim);
   }
@@ -2166,9 +2166,9 @@ static float YGDistributeFreeSpaceSecondPass(
 
     if (!currentRelativeChild->getStyle().aspectRatio.isUndefined()) {
       childCrossSize = isMainAxisRow ? (childMainSize - marginMain) /
-              currentRelativeChild->getStyle().aspectRatio.getValue()
+              currentRelativeChild->getStyle().aspectRatio.unwrap()
                                      : (childMainSize - marginMain) *
-              currentRelativeChild->getStyle().aspectRatio.getValue();
+              currentRelativeChild->getStyle().aspectRatio.unwrap();
       childCrossMeasureMode = YGMeasureModeExactly;
 
       childCrossSize += marginCross;
@@ -3135,9 +3135,9 @@ static void YGNodelayoutImpl(
                   ? child->getMarginForAxis(crossAxis, availableInnerWidth)
                           .unwrap() +
                       (isMainAxisRow ? childMainSize /
-                               child->getStyle().aspectRatio.getValue()
+                               child->getStyle().aspectRatio.unwrap()
                                      : childMainSize *
-                               child->getStyle().aspectRatio.getValue())
+                               child->getStyle().aspectRatio.unwrap())
                   : collectedFlexItemsValues.crossDim;
 
               childMainSize +=