Data Structure for block stacks

[meganindya]

This is similar to generateStacksTree() in musicblocks/js/js-export/generate.js.

Every block is represented by a JSON object. A stack of blocks is a linked list of the said objects. A clamp block creates a nesting, thus adding depth to the data structure. Arguments are a list, each of which can be chained, therefore are like a list of 1-ary tree. Finally, we'd have three global lists of all top-level stacks: start blocks, action blocks, and crumbs (the ones without any start or action); each of the three will contain lists of the data structure discussed prior. Combining these, we have a 4-dimensional recursive, hierarchical data structure.

JSON block object interfaces

interface Block {
    ... // general Block object (re musicblocks/js/block.js)
}

interface IArgBlock {
    blockType: "value" | "function",             // either it is a value block or a chaining block
    returnType: "string" | "number" | "boolean", // type of the value, or return type of chaining block
    value: string | number | boolean,            // value or the name of the chaining block
    arguments: IArgBlock[] | null,               // list of arguments for chaining block/s
    refObject: Block                             // reference object
}

interface IBlock {
    instruction: string,           // name of the block
    arguments: IArgBlock[] | null, // list of arguments
    childStack: IBlock[] | null,   // linked-list of blocks
    refObject: Block               // reference object
}

This is not exhaustive; more runtime information might be required.

Example

would be equivalent to:

{
    startBlocks: [
        {
            name: "Mr. Mouse",
            stack: [
                {
                    instruction: "settimbre",
                    arguments: [
                        {
                            blockType: "value",
                            returnType: "string",
                            value: "guitar",
                            arguments: null,
                            refObject: Block { ... }
                        }
                    ],
                    childStack: [
                        {
                            instruction: "newnote",
                            arguments: [
                                {
                                    blockType: "function",
                                    returnType: "number",
                                    value: "divide",
                                    arguments: [
                                        {
                                            blockType: "value",
                                            returnType: "number",
                                            value: 1,
                                            arguments: null,
                                            refObject: Block { ... }
                                        },
                                        {
                                            blockType: "value",
                                            returnType: "number",
                                            value: 4,
                                            arguments: null,
                                            refObject: Block { ... }
                                        }
                                    ],
                                    refObject: Block { ... }
                                }
                            ],
                            childStack: [
                                {
                                    instruction: "vspace",
                                    arguments: null,
                                    childStack: null,
                                    refObject: Block { ... }
                                },
                                {
                                    instruction: "pitch",
                                    arguments: [
                                        {
                                            blockType: "value",
                                            returnType: "string",
                                            value: "sol",
                                            arguments: null,
                                            refObject: Block { ... }
                                        },
                                        {
                                            blockType: "value",
                                            returnType: "number",
                                            value: 4,
                                            arguments: null,
                                            refObject: Block { ... }
                                        }
                                    ],
                                    childStack: null,
                                    refObject: Block { ... }
                                }
                            ],
                            refObject: Block { ... }
                        },
                        {
                            instruction: "newnote",
                            arguments: [
                                {
                                    blockType: "function",
                                    returnType: "number",
                                    value: "divide",
                                    arguments: [
                                        {
                                            blockType: "value",
                                            returnType: "number",
                                            value: 1,
                                            arguments: null,
                                            refObject: Block { ... }
                                        },
                                        {
                                            blockType: "value",
                                            returnType: "number",
                                            value: 4,
                                            arguments: null,
                                            refObject: Block { ... }
                                        }
                                    ],
                                    refObject: Block { ... }
                                }
                            ],
                            childStack: [
                                {
                                    instruction: "vspace",
                                    arguments: null,
                                    childStack: null,
                                    refObject: Block { ... }
                                },
                                {
                                    instruction: "pitch",
                                    arguments: [
                                        {
                                            blockType: "value",
                                            returnType: "string",
                                            value: "mi",
                                            arguments: null,
                                            refObject: Block { ... }
                                        },
                                        {
                                            blockType: "value",
                                            returnType: "number",
                                            value: 4,
                                            arguments: null,
                                            refObject: Block { ... }
                                        }
                                    ],
                                    childStack: null,
                                    refObject: Block { ... }
                                }
                            ],
                            refObject: Block { ... }
                        },
                        {
                            instruction: "newnote",
                            arguments: [
                                {
                                    blockType: "function",
                                    returnType: "number",
                                    value: "divide",
                                    arguments: [
                                        {
                                            blockType: "value",
                                            returnType: "number",
                                            value: 1,
                                            arguments: null,
                                            refObject: Block { ... }
                                        },
                                        {
                                            blockType: "value",
                                            returnType: "number",
                                            value: 2,
                                            arguments: null,
                                            refObject: Block { ... }
                                        }
                                    ],
                                    refObject: Block { ... }
                                }
                            ],
                            childStack: [
                                {
                                    instruction: "vspace",
                                    arguments: null,
                                    childStack: null,
                                    refObject: Block { ... }
                                },
                                {
                                    instruction: "pitch",
                                    arguments: [
                                        {
                                            blockType: "value",
                                            returnType: "string",
                                            value: "sol",
                                            arguments: null,
                                            refObject: Block { ... }
                                        },
                                        {
                                            blockType: "value",
                                            returnType: "number",
                                            value: 4,
                                            arguments: null,
                                            refObject: Block { ... }
                                        }
                                    ],
                                    childStack: null,
                                    refObject: Block { ... }
                                }
                            ],
                            refObject: Block { ... }
                        }
                    ],
                    refObject: Block { ... }
                }
            ]
        }
    ],
    actionBlocks: null,
    crumbs: null
}

I wrote this by hand so there might be mistakes.

@walterbender

[walterbender]

We need to track the screen position of the Start Blocks, Action Blocks, and crumbs somewhere. (But not the positions of any of the other blocks.)

I do like this format -- it is reasonable transparent. But it will result in files an order of magnitude larger than the ones we create now.

[meganindya]

The refObject shall refer to the runtime view object that shall store the canvas properties. This will require a reverse mapping too. This new structure will simplify the traversals. Might as well simplify the Big-O complexity of the algorithms. I think performance gain over some extra space is still a better bargain. Even with a thousand blocks the increase should only probably be a few kilobytes.