diff --git a/ReactCommon/fabric/components/view/conversions.h b/ReactCommon/fabric/components/view/conversions.h
index d4274e4de..2edafb322 100644
--- a/ReactCommon/fabric/components/view/conversions.h
+++ b/ReactCommon/fabric/components/view/conversions.h
@@ -40,7 +40,7 @@ inline Float floatFromYogaOptionalFloat(YGFloatOptional value) {
     return kFloatUndefined;
   }
 
-  return floatFromYogaFloat(value.getValue());
+  return floatFromYogaFloat(value.unwrap());
 }
 
 inline YGFloatOptional yogaOptionalFloatFromFloat(Float value) {
@@ -580,7 +580,7 @@ inline std::string toString(const YGFloatOptional &value) {
     return "undefined";
   }
 
-  return folly::to<std::string>(floatFromYogaFloat(value.getValue()));
+  return folly::to<std::string>(floatFromYogaFloat(value.unwrap()));
 }
 
 inline std::string toString(
diff --git a/ReactCommon/yoga/yoga/Utils.cpp b/ReactCommon/yoga/yoga/Utils.cpp
index 331cb6604..2035fe00c 100644
--- a/ReactCommon/yoga/yoga/Utils.cpp
+++ b/ReactCommon/yoga/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/ReactCommon/yoga/yoga/Utils.h b/ReactCommon/yoga/yoga/Utils.h
index e5e20ba3f..9ea7a7384 100644
--- a/ReactCommon/yoga/yoga/Utils.h
+++ b/ReactCommon/yoga/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/ReactCommon/yoga/yoga/YGFloatOptional.cpp b/ReactCommon/yoga/yoga/YGFloatOptional.cpp
index 0bf89f29b..d202d4d54 100644
--- a/ReactCommon/yoga/yoga/YGFloatOptional.cpp
+++ b/ReactCommon/yoga/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/ReactCommon/yoga/yoga/YGFloatOptional.h b/ReactCommon/yoga/yoga/YGFloatOptional.h
index 56bc85579..b49747982 100644
--- a/ReactCommon/yoga/yoga/YGFloatOptional.h
+++ b/ReactCommon/yoga/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/ReactCommon/yoga/yoga/YGNode.cpp b/ReactCommon/yoga/yoga/YGNode.cpp
index d930c51ae..3da72cb64 100644
--- a/ReactCommon/yoga/yoga/YGNode.cpp
+++ b/ReactCommon/yoga/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/ReactCommon/yoga/yoga/YGNodePrint.cpp b/ReactCommon/yoga/yoga/YGNodePrint.cpp
index 541a6fef9..8eb33f93e 100644
--- a/ReactCommon/yoga/yoga/YGNodePrint.cpp
+++ b/ReactCommon/yoga/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/ReactCommon/yoga/yoga/YGStyle.cpp b/ReactCommon/yoga/yoga/YGStyle.cpp
index bc90463e7..78df8b01c 100644
--- a/ReactCommon/yoga/yoga/YGStyle.cpp
+++ b/ReactCommon/yoga/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/ReactCommon/yoga/yoga/Yoga.cpp b/ReactCommon/yoga/yoga/Yoga.cpp
index 8db18e9e7..abc4ae745 100644
--- a/ReactCommon/yoga/yoga/Yoga.cpp
+++ b/ReactCommon/yoga/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 +=