More Types

More Types introduces 8 new types to PenguinMod: Object, Array, Set, Map, Symbol, Nothing, Function, and Class.

These types can be used to do all sorts of things.

All of the new types, except for Nothing, are passed by reference, meaning that each new instance you create is different from every other instance.

More Types also introduces OOP (Object Oriented Programming) to PenguinMod.

NOTE: The square inputs cannot be displayed here, and we have turned them into circular inputs.

Blocks

Here are the blocks are their usage:

print to console

print [Hello, World!] to console::#B300FF

This block outputs a value into the JavaScript console. You can open the console by pressing Ctrl + Shift + I (but don't type anything in if you don't know what you're doing).

set variable to

set [my variable v] to [0]::#B300FF

This is the same as the regular set variable block.

variable

variable [my variable v]::#B300FF reporter

This is the same as the regular get variable block, except that you know that it may not be text, a number, true or false.

new

new [Object v]::#B300FF reporter

Creates an object, array, set, or map.

typeof

typeof [Insert Anything Here]::#B300FF reporter

Gets the type of the value provided, it can be:
string,
number,
boolean,
Object,
Array,
Set,
Map,
Symbol,
nothing,
or Function.

get / set / remove Key

get key [foo] of [Insert Object / Array / Map Here]::#B300FF reporter

set key [foo] of [Insert Object / Array / Map Here] to [bar]::#B300FF

remove key [foo] of [Insert Object / Array / Map Here]::#B300FF

Here is an analogy to help you understand keys and values.
You have a giant, infinite hotel where each room is identified by its key.
When you are using "set" key, you effectively kick out whatever was inside previously, and then put in the "value", which is the thing you want to put inside the room.
When you are using "get" key, you are peeking inside the room to see what is inside the room, without affecting anything.
When you are using "remove" key, you are kicking out whatever was inside the room, and leaving it empty.

Objects, Arrays, and Maps use these keys and value
Value can be anything, but key can be different things depending on the type.

For objects, key can be a symbol or a string.
For arrays, key must be a number.
For maps, key can be anything; key can even be the map itself.
(You can delete values from sets)

add to end

add [foo] to the end of [Insert Array / Set Here]::#B300FF

Sets are really just a list of unique values, and arrays are really just a list.
This block adds a new value and puts it at the end.

exactly the same?

is [0] and [-0] EXACTLY the same?::#B300FF boolean

It's the same as Scratch's =, except it is case-sensitive, and can tell the difference between 0 and -0.
You should use this to compare objects, arrays, sets, maps, and symbols.

In?

[foo] in [Insert Object / Array / Set / Map Here]?::#B300FF boolean

It checks if key is a non-empty room. For sets, it checks if the value was previously added.

sizeof

sizeof [Insert Object / Array / Set / Map Here]::#B300FF reporter

It checks how many values are actually there.

for key value in

for key [my variable v] value [my variable v] in [Insert Object / Array / Map / Set Here] { }@loopArrow::#B300FF

It loops through the object / array / set / map. The variable after "key" is the variable which is set to the key. The variable after "value" is the variable which is set to the value.
For sets, key and value are the same.

There is also a variation of this block which uses the variables from the PenguinMod Temporary Variables extension.

create a symbol and nothing

create a symbol::#B300FF reporter nothing::#B300FF reporter

The first one creates a symbol (which is a guaranteed-to-be-unique value that can be used as an object or map key), and the second one is the special value called nothing (which is the value you get when you peek inside an empty room)

Anonymous Function / return

Anonymous Function { }::#B300FF cap return []::#B300FF cap

Anonymous Function essentially dynamically creates a custom block, which can then be "called". Return allows you to immediately stop the execution of the blocks inside of the function, and "returns" a value.

Call function

call function [Insert Function Here]::#B300FF call function [Insert Function Here] and get return value::#B300FF reporter

The first block allows you to execute the function, as the sprite it was created in, but ignores whatever value the function returned.

The seconds block does what the first block does, but it is an input, and it gets you the value that the function returned.

Classes

anonymous class { }::#B300FF cap anonymous class extends [Put in a class, or use the menu] { }::#B300FF

Classes are similar to functions, as they can execute code, but are slightly different.

Classes are basically blueprints for new objects, that can "extend" each other and be "constructed"

Extending another class is basically taking a blueprint, and modifying it. When a class extends another class, it will have access to a "super" call, which is basically calling the class that it extends before the actual class contents.

However, in More Types, you have no choice but to let the super call run.

The code inside your class can use a "this" block which will be discussed later.

This

this::#B300FF reporter

This block allows you to access the object being constructed inside classes, and allow you to access the receiver of the method (discussed later) inside a method.

Methods

append method [Insert Function Here] with name [foo] to class or object [Insert Object / Array / Set / Map / Class Here]::#B300FF call method with name [foo] on [Insert Object / Array / Set / Map Here]::#B300FF call method with name [foo] on [Insert Object / Array / Set / Map Here] and get return value::#B300FF reporter

Methods are functions that are executed with a receiver (the object the method was added to), where the receiver can be access via the "this" block.

When you append a method to an object, it creates an invisible property that can be called.

When you append a method to a class, it will create an invisible property on all current and future instances of the class (and classes that extend that class) that can be called.

Like functions, methods can execute code and return a value.

Construct

Construct an instance of [Insert Class Here]::#B300FF

This block creates an instance of the class, and executes the class on the instance.

instanceof

is [Insert Anything Here] an instance of [Put in a class, or use the menu]::#B300FF boolean

It checks if something is an instance of a class.

How to read the console

The console is incredibly complex, but this section will teach you how to read the console.

The first thing you need to do is find a textbox that says "Filter", and in this textbox you want to type in "MORE TYPES LOG:" without the quotations.

You should see all of the outputs now.

Reading objects

This section is for when you encounter the following items:

> PlainObject (Objects)

> Array (Arrays)

> Set (Sets)

> Map (Maps)

> MORETYPESCLASS (Instances of More Types classes)

For PlainObject, Array, Set, Map, and MORETYPESCLASS, you need to press the arrow, and there should be a piece of text called __values, open the arrow for that, and you should see the raw object.

The raw object is either an object ({...}), an array ([...] or Array(n)), a map (Map(n) {... => ...}), or a set (Set(n) {...}}).

For objects, the thingy before the colon (:) is the key, and the thingy after the colon (:) is the value.

For arrays, you need to expand the array, and you should see n: value, where n is the key (starts from 0) and value is the value.

For maps, you need to expand the map, and expand [[Entries]], and only look at the items after the colon (:), you should see key => value.

For sets, you need to expand the set, and expand [[Entires]], and only look at the items after the colon (:), those items are the values of inside the set.

Other Items

You can ignore all of the other things that More Types outputs, as they do not provide much information.

GitHub - Submitting an extension - Discord