Reimplement style values atop NSExpression (#10726)

* [ios, macos] Import headers, not implementation files

* [core] Added accessors for various expression parameters

Added missing parameter accessors to various expression operator classes, as well as a method on InterpolatorBase and Step that enumerates the stops and their values.

* [ios, macos] Silenced warning in test of error condition

* [ios, macos] Made MGLSphericalPosition boxable

* [ios, macos] Implemented array enumeration during conversion

* [ios, macos] Temporarily ignore heatmap layer type

* [ios, macos] Migrated MGLSymbolStyleLayer.text to NSExpression

MGLSymbolStyleLayer.text is now of type NSExpression instead of MGLStyleValue, as a first step toward migrating the entire layer API from style values to expressions.

Implemented conversions from NSExpression to JSON arrays and vice versa. The most common NSExpression functions are now converted into style expressions, but not all of the most common style expression operators are supported yet.

* [ios, macos] Implemented string coercion

* [ios, macos] Color literals

* [ios, macos] Null constant expressions

* [ios, macos] Convert dictionary literals

* [ios, macos] Interpolation expressions

* [ios, macos] to-boolean, to-number, get from object

* [ios, macos] Variable expressions

Implemented custom expression functions for assigning and referring to variables within the context of an expression. Variables are assigned via a “context dictionary” and applied to an subexpression that is given as another argument to the same expression. Also implemented built-in variable expressions for zoom level and heatmap density.

* [ios, macos] Convert colors, offsets, padding in expressions to JSON objects

* [ios, macos] Expression-based style property getters

Implemented a conversion from mbgl::style::PropertyValues to Objective-C JSON objects, which are then converted to NSExpressions.

* [ios, macos] Consolidated property value–expression conversion in MGLStyleValueTransformer

* [ios, macos] Predicate and expression guide

Extracted documentation about predicates from a documentation comment in MGLVectorStyleLayer.h to a new jazzy guide. Added details about NSExpression support as well. Began updating the “For Style Authors” guide to reflect the transition from style values to expressions.

* [ios, macos] Updated style authoring guide

Updated the Information for Style Authors guide to discuss expressions instead of style functions. Included a table mapping style specification expression operators to NSExpression syntaxes.

* [ios, macos] Migrated codegen templates to expressions

* [ios, macos] Applied expression changes via codegen

Ran make darwin-style-code.

* [macos] Migrated macosapp to expressions

* [ios, macos] Updated style function guide

This guide needs to be thoroughly rewritten, but for now the example code has been migrated to expressions.

* [ios, macos] Eviscerated style function tests

* [ios, macos] Updated changelogs

* [ios] Migrated iosapp to expressions

* [ios, macos] Exposed JSON conversion methods publicly

* [ios, macos] Removed MGLStyleValue, MGLStyleFunction

1 files changed, 168 insertions, 133 deletions

diff --git a/platform/darwin/test/MGLRasterStyleLayerTests.mm b/platform/darwin/test/MGLRasterStyleLayerTests.mm
index 26526e3a6c..5ded23ee3c 100644
--- a/platform/darwin/test/MGLRasterStyleLayerTests.mm
+++ b/platform/darwin/test/MGLRasterStyleLayerTests.mm
@@ -34,117 +34,132 @@
     {
         XCTAssertTrue(rawLayer->getRasterBrightnessMax().isUndefined(),
                       @"raster-brightness-max should be unset initially.");
-        MGLStyleValue<NSNumber *> *defaultStyleValue = layer.maximumRasterBrightness;
+        NSExpression *defaultExpression = layer.maximumRasterBrightness;
 
-        MGLStyleValue<NSNumber *> *constantStyleValue = [MGLStyleValue<NSNumber *> valueWithRawValue:@0xff];
-        layer.maximumRasterBrightness = constantStyleValue;
+        NSExpression *constantExpression = [NSExpression expressionWithFormat:@"0xff"];
+        layer.maximumRasterBrightness = constantExpression;
         mbgl::style::PropertyValue<float> propertyValue = { 0xff };
         XCTAssertEqual(rawLayer->getRasterBrightnessMax(), propertyValue,
-                       @"Setting maximumRasterBrightness to a constant value should update raster-brightness-max.");
-        XCTAssertEqualObjects(layer.maximumRasterBrightness, constantStyleValue,
-                              @"maximumRasterBrightness should round-trip constant values.");
-
-        MGLStyleValue<NSNumber *> * functionStyleValue = [MGLStyleValue<NSNumber *> valueWithInterpolationMode:MGLInterpolationModeInterval cameraStops:@{@18: constantStyleValue} options:nil];
-        layer.maximumRasterBrightness = functionStyleValue;
-
-        mbgl::style::IntervalStops<float> intervalStops = { {{18, 0xff}} };
+                       @"Setting maximumRasterBrightness to a constant value expression should update raster-brightness-max.");
+        XCTAssertEqualObjects(layer.maximumRasterBrightness, constantExpression,
+                              @"maximumRasterBrightness should round-trip constant value expressions.");
+
+        constantExpression = [NSExpression expressionWithFormat:@"0xff"];
+        NSExpression *functionExpression = [NSExpression expressionWithFormat:@"FUNCTION($zoomLevel, 'mgl_stepWithMinimum:stops:', %@, %@)", constantExpression, @{@18: constantExpression}];
+        layer.maximumRasterBrightness = functionExpression;
+
+        mbgl::style::IntervalStops<float> intervalStops = {{
+            { -INFINITY, 0xff },
+            { 18, 0xff },
+        }};
         propertyValue = mbgl::style::CameraFunction<float> { intervalStops };
         
         XCTAssertEqual(rawLayer->getRasterBrightnessMax(), propertyValue,
-                       @"Setting maximumRasterBrightness to a camera function should update raster-brightness-max.");
-        XCTAssertEqualObjects(layer.maximumRasterBrightness, functionStyleValue,
-                              @"maximumRasterBrightness should round-trip camera functions.");
+                       @"Setting maximumRasterBrightness to a camera expression should update raster-brightness-max.");
+        XCTAssertEqualObjects(layer.maximumRasterBrightness, functionExpression,
+                              @"maximumRasterBrightness should round-trip camera expressions.");
 
                               
 
         layer.maximumRasterBrightness = nil;
         XCTAssertTrue(rawLayer->getRasterBrightnessMax().isUndefined(),
                       @"Unsetting maximumRasterBrightness should return raster-brightness-max to the default value.");
-        XCTAssertEqualObjects(layer.maximumRasterBrightness, defaultStyleValue,
+        XCTAssertEqualObjects(layer.maximumRasterBrightness, defaultExpression,
                               @"maximumRasterBrightness should return the default value after being unset.");
 
-        functionStyleValue = [MGLStyleValue<NSNumber *> valueWithInterpolationMode:MGLInterpolationModeIdentity sourceStops:nil attributeName:@"" options:nil];
-        XCTAssertThrowsSpecificNamed(layer.maximumRasterBrightness = functionStyleValue, NSException, NSInvalidArgumentException, @"MGLStyleValue should raise an exception if it is applied to a property that cannot support it");
-        functionStyleValue = [MGLStyleValue<NSNumber *> valueWithInterpolationMode:MGLInterpolationModeInterval compositeStops:@{@18: constantStyleValue} attributeName:@"" options:nil];
-        XCTAssertThrowsSpecificNamed(layer.maximumRasterBrightness = functionStyleValue, NSException, NSInvalidArgumentException, @"MGLStyleValue should raise an exception if it is applied to a property that cannot support it");
+        functionExpression = [NSExpression expressionForKeyPath:@"bogus"];
+        XCTAssertThrowsSpecificNamed(layer.maximumRasterBrightness = functionExpression, NSException, NSInvalidArgumentException, @"MGLRasterLayer should raise an exception if a camera-data expression is applied to a property that does not support key paths to feature attributes.");
+        functionExpression = [NSExpression expressionWithFormat:@"FUNCTION(bogus, 'mgl_stepWithMinimum:stops:', %@, %@)", constantExpression, @{@18: constantExpression}];
+        functionExpression = [NSExpression expressionWithFormat:@"FUNCTION($zoomLevel, 'mgl_interpolateWithCurveType:parameters:stops:', 'linear', nil, %@)", @{@10: functionExpression}];
+        XCTAssertThrowsSpecificNamed(layer.maximumRasterBrightness = functionExpression, NSException, NSInvalidArgumentException, @"MGLRasterLayer should raise an exception if a camera-data expression is applied to a property that does not support key paths to feature attributes.");
     }
 
     // raster-brightness-min
     {
         XCTAssertTrue(rawLayer->getRasterBrightnessMin().isUndefined(),
                       @"raster-brightness-min should be unset initially.");
-        MGLStyleValue<NSNumber *> *defaultStyleValue = layer.minimumRasterBrightness;
+        NSExpression *defaultExpression = layer.minimumRasterBrightness;
 
-        MGLStyleValue<NSNumber *> *constantStyleValue = [MGLStyleValue<NSNumber *> valueWithRawValue:@0xff];
-        layer.minimumRasterBrightness = constantStyleValue;
+        NSExpression *constantExpression = [NSExpression expressionWithFormat:@"0xff"];
+        layer.minimumRasterBrightness = constantExpression;
         mbgl::style::PropertyValue<float> propertyValue = { 0xff };
         XCTAssertEqual(rawLayer->getRasterBrightnessMin(), propertyValue,
-                       @"Setting minimumRasterBrightness to a constant value should update raster-brightness-min.");
-        XCTAssertEqualObjects(layer.minimumRasterBrightness, constantStyleValue,
-                              @"minimumRasterBrightness should round-trip constant values.");
-
-        MGLStyleValue<NSNumber *> * functionStyleValue = [MGLStyleValue<NSNumber *> valueWithInterpolationMode:MGLInterpolationModeInterval cameraStops:@{@18: constantStyleValue} options:nil];
-        layer.minimumRasterBrightness = functionStyleValue;
-
-        mbgl::style::IntervalStops<float> intervalStops = { {{18, 0xff}} };
+                       @"Setting minimumRasterBrightness to a constant value expression should update raster-brightness-min.");
+        XCTAssertEqualObjects(layer.minimumRasterBrightness, constantExpression,
+                              @"minimumRasterBrightness should round-trip constant value expressions.");
+
+        constantExpression = [NSExpression expressionWithFormat:@"0xff"];
+        NSExpression *functionExpression = [NSExpression expressionWithFormat:@"FUNCTION($zoomLevel, 'mgl_stepWithMinimum:stops:', %@, %@)", constantExpression, @{@18: constantExpression}];
+        layer.minimumRasterBrightness = functionExpression;
+
+        mbgl::style::IntervalStops<float> intervalStops = {{
+            { -INFINITY, 0xff },
+            { 18, 0xff },
+        }};
         propertyValue = mbgl::style::CameraFunction<float> { intervalStops };
         
         XCTAssertEqual(rawLayer->getRasterBrightnessMin(), propertyValue,
-                       @"Setting minimumRasterBrightness to a camera function should update raster-brightness-min.");
-        XCTAssertEqualObjects(layer.minimumRasterBrightness, functionStyleValue,
-                              @"minimumRasterBrightness should round-trip camera functions.");
+                       @"Setting minimumRasterBrightness to a camera expression should update raster-brightness-min.");
+        XCTAssertEqualObjects(layer.minimumRasterBrightness, functionExpression,
+                              @"minimumRasterBrightness should round-trip camera expressions.");
 
                               
 
         layer.minimumRasterBrightness = nil;
         XCTAssertTrue(rawLayer->getRasterBrightnessMin().isUndefined(),
                       @"Unsetting minimumRasterBrightness should return raster-brightness-min to the default value.");
-        XCTAssertEqualObjects(layer.minimumRasterBrightness, defaultStyleValue,
+        XCTAssertEqualObjects(layer.minimumRasterBrightness, defaultExpression,
                               @"minimumRasterBrightness should return the default value after being unset.");
 
-        functionStyleValue = [MGLStyleValue<NSNumber *> valueWithInterpolationMode:MGLInterpolationModeIdentity sourceStops:nil attributeName:@"" options:nil];
-        XCTAssertThrowsSpecificNamed(layer.minimumRasterBrightness = functionStyleValue, NSException, NSInvalidArgumentException, @"MGLStyleValue should raise an exception if it is applied to a property that cannot support it");
-        functionStyleValue = [MGLStyleValue<NSNumber *> valueWithInterpolationMode:MGLInterpolationModeInterval compositeStops:@{@18: constantStyleValue} attributeName:@"" options:nil];
-        XCTAssertThrowsSpecificNamed(layer.minimumRasterBrightness = functionStyleValue, NSException, NSInvalidArgumentException, @"MGLStyleValue should raise an exception if it is applied to a property that cannot support it");
+        functionExpression = [NSExpression expressionForKeyPath:@"bogus"];
+        XCTAssertThrowsSpecificNamed(layer.minimumRasterBrightness = functionExpression, NSException, NSInvalidArgumentException, @"MGLRasterLayer should raise an exception if a camera-data expression is applied to a property that does not support key paths to feature attributes.");
+        functionExpression = [NSExpression expressionWithFormat:@"FUNCTION(bogus, 'mgl_stepWithMinimum:stops:', %@, %@)", constantExpression, @{@18: constantExpression}];
+        functionExpression = [NSExpression expressionWithFormat:@"FUNCTION($zoomLevel, 'mgl_interpolateWithCurveType:parameters:stops:', 'linear', nil, %@)", @{@10: functionExpression}];
+        XCTAssertThrowsSpecificNamed(layer.minimumRasterBrightness = functionExpression, NSException, NSInvalidArgumentException, @"MGLRasterLayer should raise an exception if a camera-data expression is applied to a property that does not support key paths to feature attributes.");
     }
 
     // raster-contrast
     {
         XCTAssertTrue(rawLayer->getRasterContrast().isUndefined(),
                       @"raster-contrast should be unset initially.");
-        MGLStyleValue<NSNumber *> *defaultStyleValue = layer.rasterContrast;
+        NSExpression *defaultExpression = layer.rasterContrast;
 
-        MGLStyleValue<NSNumber *> *constantStyleValue = [MGLStyleValue<NSNumber *> valueWithRawValue:@0xff];
-        layer.rasterContrast = constantStyleValue;
+        NSExpression *constantExpression = [NSExpression expressionWithFormat:@"0xff"];
+        layer.rasterContrast = constantExpression;
         mbgl::style::PropertyValue<float> propertyValue = { 0xff };
         XCTAssertEqual(rawLayer->getRasterContrast(), propertyValue,
-                       @"Setting rasterContrast to a constant value should update raster-contrast.");
-        XCTAssertEqualObjects(layer.rasterContrast, constantStyleValue,
-                              @"rasterContrast should round-trip constant values.");
-
-        MGLStyleValue<NSNumber *> * functionStyleValue = [MGLStyleValue<NSNumber *> valueWithInterpolationMode:MGLInterpolationModeInterval cameraStops:@{@18: constantStyleValue} options:nil];
-        layer.rasterContrast = functionStyleValue;
-
-        mbgl::style::IntervalStops<float> intervalStops = { {{18, 0xff}} };
+                       @"Setting rasterContrast to a constant value expression should update raster-contrast.");
+        XCTAssertEqualObjects(layer.rasterContrast, constantExpression,
+                              @"rasterContrast should round-trip constant value expressions.");
+
+        constantExpression = [NSExpression expressionWithFormat:@"0xff"];
+        NSExpression *functionExpression = [NSExpression expressionWithFormat:@"FUNCTION($zoomLevel, 'mgl_stepWithMinimum:stops:', %@, %@)", constantExpression, @{@18: constantExpression}];
+        layer.rasterContrast = functionExpression;
+
+        mbgl::style::IntervalStops<float> intervalStops = {{
+            { -INFINITY, 0xff },
+            { 18, 0xff },
+        }};
         propertyValue = mbgl::style::CameraFunction<float> { intervalStops };
         
         XCTAssertEqual(rawLayer->getRasterContrast(), propertyValue,
-                       @"Setting rasterContrast to a camera function should update raster-contrast.");
-        XCTAssertEqualObjects(layer.rasterContrast, functionStyleValue,
-                              @"rasterContrast should round-trip camera functions.");
+                       @"Setting rasterContrast to a camera expression should update raster-contrast.");
+        XCTAssertEqualObjects(layer.rasterContrast, functionExpression,
+                              @"rasterContrast should round-trip camera expressions.");
 
                               
 
         layer.rasterContrast = nil;
         XCTAssertTrue(rawLayer->getRasterContrast().isUndefined(),
                       @"Unsetting rasterContrast should return raster-contrast to the default value.");
-        XCTAssertEqualObjects(layer.rasterContrast, defaultStyleValue,
+        XCTAssertEqualObjects(layer.rasterContrast, defaultExpression,
                               @"rasterContrast should return the default value after being unset.");
 
-        functionStyleValue = [MGLStyleValue<NSNumber *> valueWithInterpolationMode:MGLInterpolationModeIdentity sourceStops:nil attributeName:@"" options:nil];
-        XCTAssertThrowsSpecificNamed(layer.rasterContrast = functionStyleValue, NSException, NSInvalidArgumentException, @"MGLStyleValue should raise an exception if it is applied to a property that cannot support it");
-        functionStyleValue = [MGLStyleValue<NSNumber *> valueWithInterpolationMode:MGLInterpolationModeInterval compositeStops:@{@18: constantStyleValue} attributeName:@"" options:nil];
-        XCTAssertThrowsSpecificNamed(layer.rasterContrast = functionStyleValue, NSException, NSInvalidArgumentException, @"MGLStyleValue should raise an exception if it is applied to a property that cannot support it");
+        functionExpression = [NSExpression expressionForKeyPath:@"bogus"];
+        XCTAssertThrowsSpecificNamed(layer.rasterContrast = functionExpression, NSException, NSInvalidArgumentException, @"MGLRasterLayer should raise an exception if a camera-data expression is applied to a property that does not support key paths to feature attributes.");
+        functionExpression = [NSExpression expressionWithFormat:@"FUNCTION(bogus, 'mgl_stepWithMinimum:stops:', %@, %@)", constantExpression, @{@18: constantExpression}];
+        functionExpression = [NSExpression expressionWithFormat:@"FUNCTION($zoomLevel, 'mgl_interpolateWithCurveType:parameters:stops:', 'linear', nil, %@)", @{@10: functionExpression}];
+        XCTAssertThrowsSpecificNamed(layer.rasterContrast = functionExpression, NSException, NSInvalidArgumentException, @"MGLRasterLayer should raise an exception if a camera-data expression is applied to a property that does not support key paths to feature attributes.");
         // Transition property test
         layer.rasterContrastTransition = transitionTest;
         auto toptions = rawLayer->getRasterContrastTransition();
@@ -160,117 +175,132 @@
     {
         XCTAssertTrue(rawLayer->getRasterFadeDuration().isUndefined(),
                       @"raster-fade-duration should be unset initially.");
-        MGLStyleValue<NSNumber *> *defaultStyleValue = layer.rasterFadeDuration;
+        NSExpression *defaultExpression = layer.rasterFadeDuration;
 
-        MGLStyleValue<NSNumber *> *constantStyleValue = [MGLStyleValue<NSNumber *> valueWithRawValue:@0xff];
-        layer.rasterFadeDuration = constantStyleValue;
+        NSExpression *constantExpression = [NSExpression expressionWithFormat:@"0xff"];
+        layer.rasterFadeDuration = constantExpression;
         mbgl::style::PropertyValue<float> propertyValue = { 0xff };
         XCTAssertEqual(rawLayer->getRasterFadeDuration(), propertyValue,
-                       @"Setting rasterFadeDuration to a constant value should update raster-fade-duration.");
-        XCTAssertEqualObjects(layer.rasterFadeDuration, constantStyleValue,
-                              @"rasterFadeDuration should round-trip constant values.");
-
-        MGLStyleValue<NSNumber *> * functionStyleValue = [MGLStyleValue<NSNumber *> valueWithInterpolationMode:MGLInterpolationModeInterval cameraStops:@{@18: constantStyleValue} options:nil];
-        layer.rasterFadeDuration = functionStyleValue;
-
-        mbgl::style::IntervalStops<float> intervalStops = { {{18, 0xff}} };
+                       @"Setting rasterFadeDuration to a constant value expression should update raster-fade-duration.");
+        XCTAssertEqualObjects(layer.rasterFadeDuration, constantExpression,
+                              @"rasterFadeDuration should round-trip constant value expressions.");
+
+        constantExpression = [NSExpression expressionWithFormat:@"0xff"];
+        NSExpression *functionExpression = [NSExpression expressionWithFormat:@"FUNCTION($zoomLevel, 'mgl_stepWithMinimum:stops:', %@, %@)", constantExpression, @{@18: constantExpression}];
+        layer.rasterFadeDuration = functionExpression;
+
+        mbgl::style::IntervalStops<float> intervalStops = {{
+            { -INFINITY, 0xff },
+            { 18, 0xff },
+        }};
         propertyValue = mbgl::style::CameraFunction<float> { intervalStops };
         
         XCTAssertEqual(rawLayer->getRasterFadeDuration(), propertyValue,
-                       @"Setting rasterFadeDuration to a camera function should update raster-fade-duration.");
-        XCTAssertEqualObjects(layer.rasterFadeDuration, functionStyleValue,
-                              @"rasterFadeDuration should round-trip camera functions.");
+                       @"Setting rasterFadeDuration to a camera expression should update raster-fade-duration.");
+        XCTAssertEqualObjects(layer.rasterFadeDuration, functionExpression,
+                              @"rasterFadeDuration should round-trip camera expressions.");
 
                               
 
         layer.rasterFadeDuration = nil;
         XCTAssertTrue(rawLayer->getRasterFadeDuration().isUndefined(),
                       @"Unsetting rasterFadeDuration should return raster-fade-duration to the default value.");
-        XCTAssertEqualObjects(layer.rasterFadeDuration, defaultStyleValue,
+        XCTAssertEqualObjects(layer.rasterFadeDuration, defaultExpression,
                               @"rasterFadeDuration should return the default value after being unset.");
 
-        functionStyleValue = [MGLStyleValue<NSNumber *> valueWithInterpolationMode:MGLInterpolationModeIdentity sourceStops:nil attributeName:@"" options:nil];
-        XCTAssertThrowsSpecificNamed(layer.rasterFadeDuration = functionStyleValue, NSException, NSInvalidArgumentException, @"MGLStyleValue should raise an exception if it is applied to a property that cannot support it");
-        functionStyleValue = [MGLStyleValue<NSNumber *> valueWithInterpolationMode:MGLInterpolationModeInterval compositeStops:@{@18: constantStyleValue} attributeName:@"" options:nil];
-        XCTAssertThrowsSpecificNamed(layer.rasterFadeDuration = functionStyleValue, NSException, NSInvalidArgumentException, @"MGLStyleValue should raise an exception if it is applied to a property that cannot support it");
+        functionExpression = [NSExpression expressionForKeyPath:@"bogus"];
+        XCTAssertThrowsSpecificNamed(layer.rasterFadeDuration = functionExpression, NSException, NSInvalidArgumentException, @"MGLRasterLayer should raise an exception if a camera-data expression is applied to a property that does not support key paths to feature attributes.");
+        functionExpression = [NSExpression expressionWithFormat:@"FUNCTION(bogus, 'mgl_stepWithMinimum:stops:', %@, %@)", constantExpression, @{@18: constantExpression}];
+        functionExpression = [NSExpression expressionWithFormat:@"FUNCTION($zoomLevel, 'mgl_interpolateWithCurveType:parameters:stops:', 'linear', nil, %@)", @{@10: functionExpression}];
+        XCTAssertThrowsSpecificNamed(layer.rasterFadeDuration = functionExpression, NSException, NSInvalidArgumentException, @"MGLRasterLayer should raise an exception if a camera-data expression is applied to a property that does not support key paths to feature attributes.");
     }
 
     // raster-hue-rotate
     {
         XCTAssertTrue(rawLayer->getRasterHueRotate().isUndefined(),
                       @"raster-hue-rotate should be unset initially.");
-        MGLStyleValue<NSNumber *> *defaultStyleValue = layer.rasterHueRotation;
+        NSExpression *defaultExpression = layer.rasterHueRotation;
 
-        MGLStyleValue<NSNumber *> *constantStyleValue = [MGLStyleValue<NSNumber *> valueWithRawValue:@0xff];
-        layer.rasterHueRotation = constantStyleValue;
+        NSExpression *constantExpression = [NSExpression expressionWithFormat:@"0xff"];
+        layer.rasterHueRotation = constantExpression;
         mbgl::style::PropertyValue<float> propertyValue = { 0xff };
         XCTAssertEqual(rawLayer->getRasterHueRotate(), propertyValue,
-                       @"Setting rasterHueRotation to a constant value should update raster-hue-rotate.");
-        XCTAssertEqualObjects(layer.rasterHueRotation, constantStyleValue,
-                              @"rasterHueRotation should round-trip constant values.");
-
-        MGLStyleValue<NSNumber *> * functionStyleValue = [MGLStyleValue<NSNumber *> valueWithInterpolationMode:MGLInterpolationModeInterval cameraStops:@{@18: constantStyleValue} options:nil];
-        layer.rasterHueRotation = functionStyleValue;
-
-        mbgl::style::IntervalStops<float> intervalStops = { {{18, 0xff}} };
+                       @"Setting rasterHueRotation to a constant value expression should update raster-hue-rotate.");
+        XCTAssertEqualObjects(layer.rasterHueRotation, constantExpression,
+                              @"rasterHueRotation should round-trip constant value expressions.");
+
+        constantExpression = [NSExpression expressionWithFormat:@"0xff"];
+        NSExpression *functionExpression = [NSExpression expressionWithFormat:@"FUNCTION($zoomLevel, 'mgl_stepWithMinimum:stops:', %@, %@)", constantExpression, @{@18: constantExpression}];
+        layer.rasterHueRotation = functionExpression;
+
+        mbgl::style::IntervalStops<float> intervalStops = {{
+            { -INFINITY, 0xff },
+            { 18, 0xff },
+        }};
         propertyValue = mbgl::style::CameraFunction<float> { intervalStops };
         
         XCTAssertEqual(rawLayer->getRasterHueRotate(), propertyValue,
-                       @"Setting rasterHueRotation to a camera function should update raster-hue-rotate.");
-        XCTAssertEqualObjects(layer.rasterHueRotation, functionStyleValue,
-                              @"rasterHueRotation should round-trip camera functions.");
+                       @"Setting rasterHueRotation to a camera expression should update raster-hue-rotate.");
+        XCTAssertEqualObjects(layer.rasterHueRotation, functionExpression,
+                              @"rasterHueRotation should round-trip camera expressions.");
 
                               
 
         layer.rasterHueRotation = nil;
         XCTAssertTrue(rawLayer->getRasterHueRotate().isUndefined(),
                       @"Unsetting rasterHueRotation should return raster-hue-rotate to the default value.");
-        XCTAssertEqualObjects(layer.rasterHueRotation, defaultStyleValue,
+        XCTAssertEqualObjects(layer.rasterHueRotation, defaultExpression,
                               @"rasterHueRotation should return the default value after being unset.");
 
-        functionStyleValue = [MGLStyleValue<NSNumber *> valueWithInterpolationMode:MGLInterpolationModeIdentity sourceStops:nil attributeName:@"" options:nil];
-        XCTAssertThrowsSpecificNamed(layer.rasterHueRotation = functionStyleValue, NSException, NSInvalidArgumentException, @"MGLStyleValue should raise an exception if it is applied to a property that cannot support it");
-        functionStyleValue = [MGLStyleValue<NSNumber *> valueWithInterpolationMode:MGLInterpolationModeInterval compositeStops:@{@18: constantStyleValue} attributeName:@"" options:nil];
-        XCTAssertThrowsSpecificNamed(layer.rasterHueRotation = functionStyleValue, NSException, NSInvalidArgumentException, @"MGLStyleValue should raise an exception if it is applied to a property that cannot support it");
+        functionExpression = [NSExpression expressionForKeyPath:@"bogus"];
+        XCTAssertThrowsSpecificNamed(layer.rasterHueRotation = functionExpression, NSException, NSInvalidArgumentException, @"MGLRasterLayer should raise an exception if a camera-data expression is applied to a property that does not support key paths to feature attributes.");
+        functionExpression = [NSExpression expressionWithFormat:@"FUNCTION(bogus, 'mgl_stepWithMinimum:stops:', %@, %@)", constantExpression, @{@18: constantExpression}];
+        functionExpression = [NSExpression expressionWithFormat:@"FUNCTION($zoomLevel, 'mgl_interpolateWithCurveType:parameters:stops:', 'linear', nil, %@)", @{@10: functionExpression}];
+        XCTAssertThrowsSpecificNamed(layer.rasterHueRotation = functionExpression, NSException, NSInvalidArgumentException, @"MGLRasterLayer should raise an exception if a camera-data expression is applied to a property that does not support key paths to feature attributes.");
     }
 
     // raster-opacity
     {
         XCTAssertTrue(rawLayer->getRasterOpacity().isUndefined(),
                       @"raster-opacity should be unset initially.");
-        MGLStyleValue<NSNumber *> *defaultStyleValue = layer.rasterOpacity;
+        NSExpression *defaultExpression = layer.rasterOpacity;
 
-        MGLStyleValue<NSNumber *> *constantStyleValue = [MGLStyleValue<NSNumber *> valueWithRawValue:@0xff];
-        layer.rasterOpacity = constantStyleValue;
+        NSExpression *constantExpression = [NSExpression expressionWithFormat:@"0xff"];
+        layer.rasterOpacity = constantExpression;
         mbgl::style::PropertyValue<float> propertyValue = { 0xff };
         XCTAssertEqual(rawLayer->getRasterOpacity(), propertyValue,
-                       @"Setting rasterOpacity to a constant value should update raster-opacity.");
-        XCTAssertEqualObjects(layer.rasterOpacity, constantStyleValue,
-                              @"rasterOpacity should round-trip constant values.");
-
-        MGLStyleValue<NSNumber *> * functionStyleValue = [MGLStyleValue<NSNumber *> valueWithInterpolationMode:MGLInterpolationModeInterval cameraStops:@{@18: constantStyleValue} options:nil];
-        layer.rasterOpacity = functionStyleValue;
-
-        mbgl::style::IntervalStops<float> intervalStops = { {{18, 0xff}} };
+                       @"Setting rasterOpacity to a constant value expression should update raster-opacity.");
+        XCTAssertEqualObjects(layer.rasterOpacity, constantExpression,
+                              @"rasterOpacity should round-trip constant value expressions.");
+
+        constantExpression = [NSExpression expressionWithFormat:@"0xff"];
+        NSExpression *functionExpression = [NSExpression expressionWithFormat:@"FUNCTION($zoomLevel, 'mgl_stepWithMinimum:stops:', %@, %@)", constantExpression, @{@18: constantExpression}];
+        layer.rasterOpacity = functionExpression;
+
+        mbgl::style::IntervalStops<float> intervalStops = {{
+            { -INFINITY, 0xff },
+            { 18, 0xff },
+        }};
         propertyValue = mbgl::style::CameraFunction<float> { intervalStops };
         
         XCTAssertEqual(rawLayer->getRasterOpacity(), propertyValue,
-                       @"Setting rasterOpacity to a camera function should update raster-opacity.");
-        XCTAssertEqualObjects(layer.rasterOpacity, functionStyleValue,
-                              @"rasterOpacity should round-trip camera functions.");
+                       @"Setting rasterOpacity to a camera expression should update raster-opacity.");
+        XCTAssertEqualObjects(layer.rasterOpacity, functionExpression,
+                              @"rasterOpacity should round-trip camera expressions.");
 
                               
 
         layer.rasterOpacity = nil;
         XCTAssertTrue(rawLayer->getRasterOpacity().isUndefined(),
                       @"Unsetting rasterOpacity should return raster-opacity to the default value.");
-        XCTAssertEqualObjects(layer.rasterOpacity, defaultStyleValue,
+        XCTAssertEqualObjects(layer.rasterOpacity, defaultExpression,
                               @"rasterOpacity should return the default value after being unset.");
 
-        functionStyleValue = [MGLStyleValue<NSNumber *> valueWithInterpolationMode:MGLInterpolationModeIdentity sourceStops:nil attributeName:@"" options:nil];
-        XCTAssertThrowsSpecificNamed(layer.rasterOpacity = functionStyleValue, NSException, NSInvalidArgumentException, @"MGLStyleValue should raise an exception if it is applied to a property that cannot support it");
-        functionStyleValue = [MGLStyleValue<NSNumber *> valueWithInterpolationMode:MGLInterpolationModeInterval compositeStops:@{@18: constantStyleValue} attributeName:@"" options:nil];
-        XCTAssertThrowsSpecificNamed(layer.rasterOpacity = functionStyleValue, NSException, NSInvalidArgumentException, @"MGLStyleValue should raise an exception if it is applied to a property that cannot support it");
+        functionExpression = [NSExpression expressionForKeyPath:@"bogus"];
+        XCTAssertThrowsSpecificNamed(layer.rasterOpacity = functionExpression, NSException, NSInvalidArgumentException, @"MGLRasterLayer should raise an exception if a camera-data expression is applied to a property that does not support key paths to feature attributes.");
+        functionExpression = [NSExpression expressionWithFormat:@"FUNCTION(bogus, 'mgl_stepWithMinimum:stops:', %@, %@)", constantExpression, @{@18: constantExpression}];
+        functionExpression = [NSExpression expressionWithFormat:@"FUNCTION($zoomLevel, 'mgl_interpolateWithCurveType:parameters:stops:', 'linear', nil, %@)", @{@10: functionExpression}];
+        XCTAssertThrowsSpecificNamed(layer.rasterOpacity = functionExpression, NSException, NSInvalidArgumentException, @"MGLRasterLayer should raise an exception if a camera-data expression is applied to a property that does not support key paths to feature attributes.");
         // Transition property test
         layer.rasterOpacityTransition = transitionTest;
         auto toptions = rawLayer->getRasterOpacityTransition();
@@ -286,39 +316,44 @@
     {
         XCTAssertTrue(rawLayer->getRasterSaturation().isUndefined(),
                       @"raster-saturation should be unset initially.");
-        MGLStyleValue<NSNumber *> *defaultStyleValue = layer.rasterSaturation;
+        NSExpression *defaultExpression = layer.rasterSaturation;
 
-        MGLStyleValue<NSNumber *> *constantStyleValue = [MGLStyleValue<NSNumber *> valueWithRawValue:@0xff];
-        layer.rasterSaturation = constantStyleValue;
+        NSExpression *constantExpression = [NSExpression expressionWithFormat:@"0xff"];
+        layer.rasterSaturation = constantExpression;
         mbgl::style::PropertyValue<float> propertyValue = { 0xff };
         XCTAssertEqual(rawLayer->getRasterSaturation(), propertyValue,
-                       @"Setting rasterSaturation to a constant value should update raster-saturation.");
-        XCTAssertEqualObjects(layer.rasterSaturation, constantStyleValue,
-                              @"rasterSaturation should round-trip constant values.");
-
-        MGLStyleValue<NSNumber *> * functionStyleValue = [MGLStyleValue<NSNumber *> valueWithInterpolationMode:MGLInterpolationModeInterval cameraStops:@{@18: constantStyleValue} options:nil];
-        layer.rasterSaturation = functionStyleValue;
-
-        mbgl::style::IntervalStops<float> intervalStops = { {{18, 0xff}} };
+                       @"Setting rasterSaturation to a constant value expression should update raster-saturation.");
+        XCTAssertEqualObjects(layer.rasterSaturation, constantExpression,
+                              @"rasterSaturation should round-trip constant value expressions.");
+
+        constantExpression = [NSExpression expressionWithFormat:@"0xff"];
+        NSExpression *functionExpression = [NSExpression expressionWithFormat:@"FUNCTION($zoomLevel, 'mgl_stepWithMinimum:stops:', %@, %@)", constantExpression, @{@18: constantExpression}];
+        layer.rasterSaturation = functionExpression;
+
+        mbgl::style::IntervalStops<float> intervalStops = {{
+            { -INFINITY, 0xff },
+            { 18, 0xff },
+        }};
         propertyValue = mbgl::style::CameraFunction<float> { intervalStops };
         
         XCTAssertEqual(rawLayer->getRasterSaturation(), propertyValue,
-                       @"Setting rasterSaturation to a camera function should update raster-saturation.");
-        XCTAssertEqualObjects(layer.rasterSaturation, functionStyleValue,
-                              @"rasterSaturation should round-trip camera functions.");
+                       @"Setting rasterSaturation to a camera expression should update raster-saturation.");
+        XCTAssertEqualObjects(layer.rasterSaturation, functionExpression,
+                              @"rasterSaturation should round-trip camera expressions.");
 
                               
 
         layer.rasterSaturation = nil;
         XCTAssertTrue(rawLayer->getRasterSaturation().isUndefined(),
                       @"Unsetting rasterSaturation should return raster-saturation to the default value.");
-        XCTAssertEqualObjects(layer.rasterSaturation, defaultStyleValue,
+        XCTAssertEqualObjects(layer.rasterSaturation, defaultExpression,
                               @"rasterSaturation should return the default value after being unset.");
 
-        functionStyleValue = [MGLStyleValue<NSNumber *> valueWithInterpolationMode:MGLInterpolationModeIdentity sourceStops:nil attributeName:@"" options:nil];
-        XCTAssertThrowsSpecificNamed(layer.rasterSaturation = functionStyleValue, NSException, NSInvalidArgumentException, @"MGLStyleValue should raise an exception if it is applied to a property that cannot support it");
-        functionStyleValue = [MGLStyleValue<NSNumber *> valueWithInterpolationMode:MGLInterpolationModeInterval compositeStops:@{@18: constantStyleValue} attributeName:@"" options:nil];
-        XCTAssertThrowsSpecificNamed(layer.rasterSaturation = functionStyleValue, NSException, NSInvalidArgumentException, @"MGLStyleValue should raise an exception if it is applied to a property that cannot support it");
+        functionExpression = [NSExpression expressionForKeyPath:@"bogus"];
+        XCTAssertThrowsSpecificNamed(layer.rasterSaturation = functionExpression, NSException, NSInvalidArgumentException, @"MGLRasterLayer should raise an exception if a camera-data expression is applied to a property that does not support key paths to feature attributes.");
+        functionExpression = [NSExpression expressionWithFormat:@"FUNCTION(bogus, 'mgl_stepWithMinimum:stops:', %@, %@)", constantExpression, @{@18: constantExpression}];
+        functionExpression = [NSExpression expressionWithFormat:@"FUNCTION($zoomLevel, 'mgl_interpolateWithCurveType:parameters:stops:', 'linear', nil, %@)", @{@10: functionExpression}];
+        XCTAssertThrowsSpecificNamed(layer.rasterSaturation = functionExpression, NSException, NSInvalidArgumentException, @"MGLRasterLayer should raise an exception if a camera-data expression is applied to a property that does not support key paths to feature attributes.");
         // Transition property test
         layer.rasterSaturationTransition = transitionTest;
         auto toptions = rawLayer->getRasterSaturationTransition();