You're building a component that connects to a text generation model (like GPT, LLaMA, or Mistral) and streams output tokens as they are generated. Each token is a single string, sent one at a time. This makes it a perfect candidate for using the atomic type String.

An example definition of the Atomic type String in Pipelang, Python, and C++:

String

The code block below shows example values that can be assigned to the List in Pipelang, Python, C++, and JSON:

"Hello"
"world"
","
"how"
"are"
"you"
"?"

You’re building a component that aggregates error codes from edge IoT devices and sends them periodically as a list. Each device accumulates a list of recent Int32 error codes, and your component emits this list every few seconds. This is useful for components that track device stability, trigger alerts if certain codes appear, or count frequency of specific errors.

An example definition of the List type in Pipelang, Python, and C++:

[Int32]

The code block below shows example values that can be assigned to the List in Pipelang, Python, C++, and JSON:

[102, 504, 102, 301]

You're building a component that receives raw GPS data from a sensor and emits a data stream containing latitude (Float) and longitude (Float). This data doesn’t need named fields — the order of elements carries meaning. Every reading follows the same position-based convention.

An example definition of the Tuple type in Pipelang, Python, and C++:

(Float, Float)

The code block below shows example values that can be assigned to the Tuple in Pipelang, Python, C++, and JSON:

[48.1374, 11.5755]

You're building a vehicle monitoring system for a parking garage. One component processes camera input and extracts structured information about each detected vehicle — including: (a) license plate number (text), (b) confidence score of detection (float), (c) time of detection (timestamp), and (d) the camera ID (int) where the vehicle was seen.

You want to package all this together into a structured output so it’s easy for downstream components to consume.

An example definition of the Record type in Pipelang, Python, and C++:

{
    plate: String,
    confidence: Float,
    timestamp: UInt64,
    camera_id: Int32
}

The code block below shows example values that can be assigned to the Record in Pipelang, Python, C++, and JSON:

{
    plate: "ABC-1234",
    confidence: 0.93,
    timestamp: 1728483923,
    camera_id: 7
}

In a smart TV input component called Input Google TV, users can set the volume level either by: (a) Using a remote control, which sends whole numbers like 25, 50, or 100 (Int32), or (b) via voice command or slider, which may produce decimal values like 32.5 or 47.2 (Float). You want to allow both styles of input for maximum UX flexibility, but treat them as equivalent in logic.

In Pipelogic, union types are written using the | operator. This means a value can be either an Int32 or a Float, but not both at the same time.

An example definition of the Union type in Pipelang, Python, and C++:

Int32 | Float

The code block below shows example values that can be assigned to the Union in Pipelang, Python, C++, and JSON:

# Int32
5
# or Float
5.25

In a project involving anomaly detection from smart meter readings in a power plant, we built a classification component called Classify Anomaly. This component returns a named type called DetectedClass, which contains a class ID and its associated confidence score.

The code block below shows an example definition of the DetectedClass named type in Pipelang, Python, and C++:

{
    id: UInt64,
    confidence: Double
}

The code block below shows example values that can be assigned to the named type DetectedClass in Pipelang, Python, C++, and JSON:

{
    id: 451,
    confidence: 0.978
}

You’re building a Pipelogic component that analyzes customer support chats in real time. Each chat message comes with metadata like sender info, timestamp, and a sentiment analysis result. Instead of using one big record, you break the data into named types for reusability and clarity.

The code block below shows an example definition of nested named types in Pipelang, Python, and C++:

{
    sender: User,
    message: String,
    timestamp: UInt64,
    sentiment: Sentiment
}

The code block below shows example values that can be assigned to nested named types in Pipelang, Python, C++, and JSON:

{
    sender: {
        id: 3344,
        name: "Jane Doe",
        is_agent: false
    },
    message: "I'm really frustrated with my last order!",
    timestamp: 1717542001,
    sentiment: {
        label: "negative",
        score: 0.91
    }
}

You're developing a Pipelogic component that performs geometric calculations — such as measuring distances or resizing bounding boxes. These calculations could work with various numeric types (Int32, Float, Double) depending on the source of the data. Instead of rewriting the same logic for each numeric type, you can define the component using a generic type variable, so it works with any numeric type. This approach allows you to write type-safe, reusable, and flexible logic using type variables — also known as generics.

The code block below shows an example definition of the Generic type in Pipelang, Python, and C++:

Point<t> := {
    x: t,
    y: t
}

Rectangle<t> := {
    top_left: Point<t>,
    bottom_right: Point<t>
}

The code block below shows example values that can be assigned to the named type Generic type in Pipelang, Python, C++, and JSON:

{
    top_left: { x: 12.5, y: 20.0 },
    bottom_right: { x: 100.0, y: 220.5 }
}