Skip to main content

Define an expression

In this tutorial, you will define expressions within a pipeline operation to transform data of primitive type.

You will perform different functions:

  • define a trivial arithmetic Expression,
  • define sequential operations,
  • combine sequential operations,
  • define a trivial comparison Expression, and
  • define a trivial branching Expression.

This lesson will assume that you have an empty project and asset which you can to deploy to a workspace named 03_02_05_define_an_expression with the following command:

edk template deploy -ycw 03_02_05_define_an_expression

Define a Trivial Arithmetic Expression

In this exercise, you will define an arithmetic Expression within your transform() Operation. The Operation that you define will:

  • add an integer value of 1 to the value of Writeable.My Source, and
  • evaluate the new value in the output datastream of your pipeline.

In an asset, define the Operation with an Add() Expression, insert your variable name and the integer expression Const(1n).

import { SourceBuilder, PipelineBuilder, Template, Add, Const } from "@elaraai/core";

const my_source = new SourceBuilder("My Source")
    .value({ value: 2n });

const my_pipeline = new PipelineBuilder("My Pipeline")
    .from(my_source.outputStream())
    // add 1 to the stream
    .transform((stream) => Add(stream, Const(1n)));

export default Template(my_source, my_pipeline);

So far, you have applied two expressions; deploying this solution and viewing the output using edk stream get will result in a value for "My Pipeline" of 1 greater than the value of the Writeable.My Source datastream value.

Note that:
  • stream is a Variable Expression, and is only available within the lexical scope of the .transform() Operation.
  • Const(1n) is a Constant Expression. The integer 1 is concatenated with n because IntegerType Value expressions use TypeScript bigint notation.
  • Since addition is cummutative (i.e a + b = b + a), Add(stream, Const(1n)) and Add(Const(1n), stream) are equivalent and either can be used.

Define sequential operations

You can define a series of operations to be performed in sequence by calling their methods sequentially from your PipelineBuilder() instance.

To add 1 to a value, and then multiply the result by 5, add a second transform() method call after the first that was defined in the previous exercise.

import { SourceBuilder, PipelineBuilder, Template, Add, Const, Multiply } from "@elaraai/core";

const my_source = new SourceBuilder("My Source").value({ value: 2n });

const my_pipeline = new PipelineBuilder("My Pipeline")
    .from(my_source.outputStream())
    .transform((stream) => Add(stream, Const(1n)))
    // add another operation and multiple the result of the previous by 5
    .transform((stream) => Multiply(stream, Const(5n)));

export default Template(my_source, my_pipeline);

As mentioned previously, each Operation outputs its own datastream value, and subsequent operations are performed on the datastream from the preceding Operation.

Combine multiple expressions

Using multiple operations can be inefficient. Each defined Operation generates a datastream itself, and large datastreams can make a solution slow to evaluate.

Condense your pipeline definition to one Operation by nesting the Add() Function Expression as an argument of the Multiply() Function Expression.

import { SourceBuilder, PipelineBuilder, Template, Add, Const, Multiply } from "@elaraai/core";

const my_source = new SourceBuilder("My Source").value({ value: 2n });

const my_pipeline = new PipelineBuilder("My Pipeline")
    .from(my_source.outputStream())
    // combine into a single expression
    .transform((stream) => Multiply(Add(stream, Const(1n)), Const(5n)));

export default Template(my_source, my_pipeline);

Define a Trivial Comparison Expression

Comparison expressions can be used on Primitive type values in a datastream, which will compare two values and generate a BooleanType value. Comparisons for IntegerType values include Equal(), NotEqual(), Greater(), GreaterEqual(), Less and LessEqual().

Define an Equal() comparison Expression in your pipeline.

import { SourceBuilder, PipelineBuilder, Template, Equal, Const } from "@elaraai/core";

const my_source = new SourceBuilder("My Source").value({ value: 2n });

const my_pipeline = new PipelineBuilder("My Pipeline")
    .from(my_source.outputStream())
    // change to a comparison to output a different type
    .transform((stream) => Equal(stream, Const(10n)));

export default Template(my_source, my_pipeline);

The Equal() Expression evaluates whether the value of the datastream is equal to the integer 10. If so, it evaluates as true, otherwise evaluates as false. Note here that the output datastream does not share the same type as the input datastream in a pipeline Operation (BooleanType instead of IntegerType).

Define a Trivial Branching Expression

IfElse() expressions can be used on primitive type values in a datastream.

In your pipeline, define an IfElse() Expression using a BooleanType Function Expression as the first argument and IntegerType value expressions as the second and third arguments.

import { SourceBuilder, PipelineBuilder, Template, Equal, IfElse, Const } from "@elaraai/core"

const my_source = new SourceBuilder("My Source")
    .value({ value: 2n })

const my_pipeline = new PipelineBuilder("My Pipeline")
    .from(my_source.outputStream())
    .transform(stream => IfElse(
        Equal(stream, Const(10n)),
        Const(100n),
        Const(1n)
    ))

export default Template(my_source, my_pipeline)

The IfElse() Expression evaluates it's first argument conditional clause Equal(). If this Function Expression evaluates as true, the second argument Value Expression Const(100n) is evaluated. Otherwise if false, the third argument Value Expression Const(1n) is evaluated.

Launch and interact with your pipeline

To validate the output of your newly defined pipeline, read it's output datastream Pipeline.My Pipeline using the following command:

edk stream get "Pipeline.My Pipeline"  -w 03_02_05_define_an_expression

Which will result in the following confirmation that the output datastream of My Pipeline has a value of "1", since the output datastream of My Source has a value of "2":

▹▹▹▹▹ Attempting to stream Pipeline.My Pipeline to stdout
"1"
✔ Download complete

For further confirmation, you can change the value of Writeable.My Source by running the following command:

edk stream replace "Writeable.My Source" --format "json" --value 10 -w 03_02_05_define_an_expression

Which will result in the following confirmation that the output datastream of My Pipeline now has a value of "100", since the output datastream of My Source has a value of "10":

▹▹▹▹▹ Attempting to stream Pipeline.My Pipeline to stdout
"100"
✔ Download complete

Further Reading

Read the

primitive data module for a more detailed understanding of working with primitive expressions.

Example solution

The code for this tutorial is available below:

Next steps

In this tutorial, you defined expressions and pipeline operations using several different approaches to transform data of primitive type. You learnt simple arithmetic, comparison and branching expressions, as well as how to apply multiple operations.

So far in this learning module, you have only been performing pipeline operations involving a single target input datastream. In the next tutorial, you will learn how to input additional datastreams to be used in pipeline operations.

On this page