Learning DeadCL DeadCL Tutorials DeadCL Syntax DeadCL MBS

Walk throughs

Author Keys Conversations Libraries Arrays

  Network Status Community Hub Contact Us


(deadCL Syntax)

deadCL uses Variators to aid explicit interpretation by RI.

They're among the most difficult components of deadCL to understand, the following examples should aid you forming a basic understanding - if you have any questions best to visit our Community hub.

C [   ]

Indicates objects contained can be treated as fluid for recursive interpretations


Within deadCL we use C [   ] to inform when an object is to be treated as fluid and/or recursive for the purposes of RI interpretations

For example we use C [   ] to set an object value for interpretation

In this instance the value is 'var_2xb'

C [ var_2xb ]


Prompt for interpretation of object(s), useful to create/manage abstract information


Within deadCL we use C_impress to initiate an RI interpretation of an object or string.

For example we use C_impress to form an abstract object from fixed object information.

For instance here we're using object information stored within an array to form an interpretable value for $_word

$_word; C_impress _VAL -- A OB[30.22]

C_var(   )

Contents between the parentheses is a variable object (string)


Within deadCL we use C_var(   ) to form variable object strings - for RI.

For example we use C_var(   ) when we need to change an object into a variable object strings.

For instance when we need create a variable (interpretable) string from the values X & Y


C#{   }

Tokenise object(s)


Within deadCL we use C#{   } to both represent & initiate tokenised objects within deadCL Libraries and Arrays.

Tokenising is essential for RI object output.

For example we use C#{   } to POST abstract tokens as 'output'

For example when a token is represented by the value $

?DRP -- {//POST 'C#{$}' output}

We can also use C#{   } to create tokens of (& for) other elements in deadCL (RI).

For example when creating an isolated interpretable token using a C_POST



Interpretable object comes after


Within deadCL we use inpr_ to inform when a solely interpretable object (or strings) comes after.

inpr_ should never be used in conjunction with MBS.

For example we use inpr_ to indicate the presents of a pure interpretable object.

This example is for the value "C[X, itm_0 -- Y, itm_1]"

inpr_{ C[X, itm_0 -- Y, itm_1] }


List object variables for following statement


Within deadCL we use var_ to form lists of object values (within a value).

For example we use var_ to create a list of the values contained by another.

Here we're using var_ to add the values of '112-word'


var(   )

Contents between the parenthesis is a variable object (string)


Within deadCL we use var(   ) to create manual object strings.

Variable objects strings created in this manner are generally composed of objects within the same library or resource.

For example we use var(   ) to create constant data points.

For example we're using 'V0, V1, V2, V3' as our variables within a string.

var(V0, V1, V2, V3)

C_inpr(   )

Interpretable output will post between the parenthesis


Within deadCL we use C_inpr(   ) to post interpretable output, this can be for further processing or be placed within a POST command from the Library.

For example we use C_inpr(   ) to assign a post value to a seperate value.

In this example '$'

C_inpr( $ )

We can also C_inpr(   ) to easily inform a POST request.

For example here our post value is 'MM*'

C_POST; C_inpr( MM* )


Force an object flush


Within deadCL we use C_FLUSH to flush out/stop or remove a current process in-motion.

This is a necessity within certain applications given deadCL runs all files from 'top to bottom'.

For example we use C_FLUSH to stop the KC 'ACT03' this is only possible if the KC 'ACT03' is processed before the flush request.



Recall interpretable output


Within deadCL we use C_PULL to retrieve object information from resources we've already processed.

For example we use C_PULL to recall certain object information.

In this example 'ren' as an authoritative object.

C_PULL {ren}


Post output for isolated interpretation


Within deadCL we use C_POST to make RI output post interpretations (in isolation).

For example we use C_POST to speedily POST just the value of 'APPLE'

C_POST; C_inpr( APPLE )