Challenge: bi-directional terminal view. (I/O)

[compsystems]

Sorry, for very bad google translation

Hello, the vast majority of graphics terminals are (I / O). You can simulate this feature by replicating keyboard input by printing the value on the output.

print( ">"+radius );
print( ">" + base );

for the student to switch to a language like c ++, see a functional similarity between hp-prime and c ++ code

Examples

Therefore, hp-prime team requires a command to read the data from the terminal view, the challenge is to make the terminal view bi-directional input and output of data.

PHP Code:

export Area_of_Circle()
begin
  local radius, area;
  print();
  print( "please enter the radius of a circle" );   wait;
  input( radius ); print( ">"+radius );
  area := 3.14 * radius ^ 2; 
  print( "the area is :" + area );
  return "done";
end; 


PHP Code:

export area, base, height, answer;
//export area, base:=3, height:=4, answer;
const const1:= '1/2';
export Area_of_Triangle()
begin
    // local area, base, height, answer;
    print();
    area := const1*'(base * height)';
    print2d( 'area'=area ); // FIRMWARE )2021
    print( "Please enter the base of the triangle " );   wait;
    input( base ); print( ">" + base ); 
    print( "Please enter the height of the triangle " );   wait;
    input( height ); print( ">" + height ); 
    answer := eval(area); 
    print( "The area of the triangle is: " + answer );
    return { 'base'=base, 'height'=height, area=answer };
end; 


[compsystems]

(07-12-2020 08:26 PM)DrD Wrote:  As subject matter expert, a trivial exercise for you is to make a "bi-directional terminal view." Imagine, you could rotate text, or make feature-rich fonts! Don't wait for "hp-prime team," realize your own challenge, bring your dream to life!

hp-prime team made BLIT_P, GETPIX_P, PIXON_P, PIXOFF_P, RECT_P, and TEXTOUT_P. The tools are already there, require yourself to show us the way, sir.

I can do it. Also, I already did that on the hp50. Explore the following RPL-encoded application.
This interface emulates the I/O of the TIvoyage200/TI89 calculator, it also contains a bidirectional terminal.
https://www.hpcalc.org/details/7282


The point is, I'm teaching algorithmic logic to high school students. We need a platform that provides a simple I/O data interface embeded, not a INFORM, that confuses them.

statement to read string data
Input( { { name, [ 2 ] } } ) ;

Hp-prime numerical code (Home)

PHP Code:

export split_string()
begin
  local name, n;
  print();
  print( " Please enter your name " );   wait;
  input( { {name, [ 2 ] } } );  // =(
  print( ">" + name ); 
  for n from 1 to dim(name) step 1 do
      print( mid( name, n, 1 ) ) ; 
  end; 
  return "Done";
end; 


Comparison of inform versus input cmd.




Inform command tutorial.

PHP Code:

// versión 0.0.9e - mar 23/2017 by: CompSystems

// Los primeros ejemplos es un demostración general del uso de la orden INPUT, luego se muestran desde el caso mas simple hasta el mas complejo

//Global for this file
//xx := 0;
//yy := 0;

//Global and visible variables for all files
export xx := 7;
export yy := 6;
export zz := 5;
export inputv0()
BEGIN
  // request xx, yy, zz data
  //xx := 5;
  print( );
  print( "input cmd with a variable" ); wait;
  input( xx );
  print( "foo1()" ); wait;
  //foo1();
  input( yy );
  print( "foo2()" ); wait;
  //foo2();
  input( zz );
  print( "foo3()" ); wait;
  //foo3();
  return { "xx: "+xx, "yy: "+yy, "zz: "+zz };
END;

export inputDemo()
begin
  local r;
  local resetVAL_r;
  local initVAL_r;
  initVAL_r := 1;
  initVAL_r := 5; 
  local ObjectType_Real := 0;
  local ObjectType := ObjectType_Real; 
  local title := "input cmd, demo";
  local ok := true;
  local cancel := false;
  local keyPressedOnMenu := cancel;
  keyPressedOnMenu := input
  (
  {
  { r, [ ObjectType ] }
  },
  title,
  { "Radious:" },
  { "Entre radious" },
  { resetVAL_r },
  { initVAL_r }
  );
  if keyPressedOnMenu == ok then
    return( "Area: " + pi*r^2 +"u²" );
    else
    return "Done";
  end;
end;

export inputv01()
BEGIN
    // I: La forma más simple de INPUT CMD, requiere un solo argumento, el nombre de la variable a modificar

    // ARGUMENTO#1 variable(s) obligatoria(s): por ejemplo xx
    // ARGUMENTO#2 etiqueta opcional: si no se incluye este argumento, se agrega automáticamente a la caja de dialogo
    // el mismo nombre de la variable más ":" , en este caso "xx:"
    // ARGUMENTO#3 titulo opcional de la caja de dialogo: por defecto coloca el nombre "Input"
    // ARGUMENTO#4 ayuda opcional: agrega la cadena "Enter value for" + nombre de la variable, en este caso 
    // "Enter value for xx" si la calculadora está en language/English
    // ARGUMENTO#5 valores opcionales de restablecimiento de cada variable
    // ARGUMENTO#6 valores iniciales que se muestran en cada variable (opcionales)
    local xx;
    xx := 4; // valor inicial constante de la variable de almacenamiento siempre que se llame a la orden de usuario inputv01()
    input( xx ); // un solo argumento
    // [enter] ó [ok] ejecuta los campos de la caja de dialogo
    // [esc] ó [cancel] sale de la caja de dialogo sin modificar los campos de entrada.

    return "xx: "+xx;
END;



//Código anterior sin comentarios
export inputv1()
BEGIN
    local xx;
    xx := 4;  
    input( xx ); 
    return "xx: "+xx;
END;


export inputFX()
BEGIN
    F1:= 'X^2';  
    input( F1 ); 
    return "F1: "+F1;
END;

export unitVar, strVar;
export inputTypes()
BEGIN
  X:=0; Y:=0;

  //initVAL_a := #FFFh; initVAL_b := #FFh; initVAL_c := #Fh; // integer 1
  //initVAL_a := "abc"; initVAL_b := "123"; initVAL_c := "\"X\""; // string 2
  //initVAL_a := i; initVAL_b := (3,4); initVAL_c := 3+4*i; // complex 3
  //initVAL_a := [1]; initVAL_b := [2]; initVAL_c := [3]; // matrix 4
  //initVAL_a := {1}; initVAL_b := {2}; initVAL_c := {3}; // list 6
  //initVAL_a := 1_m; initVAL_b := 2_cm; initVAL_c := 3_inch; // unit 9
  //resetVAL_a := 0; resetVAL_b := 0; resetVAL_c := 0; // real 0
  //resetVAL_a := 0; resetVAL_b := 0; resetVAL_c := 0; // integer 1
  //resetVAL_a := ""; resetVAL_b := ""; resetVAL_c := ""; // string 2
  //resetVAL_a := 0; resetVAL_b := 0; resetVAL_c := 0; // complex 3
  //resetVAL_a := [0]; resetVAL_b := [0]; resetVAL_c := [0]; // matrix 4
  //resetVAL_a := {}; resetVAL_b := {}; resetVAL_c := {}; // list 6
  //resetVAL_a := 'X'; resetVAL_b := 'X'; resetVAL_c := 'X'; // function 8
  //resetVAL_a := 0_u; resetVAL_b := 0_u; resetVAL_c := 0_u; // unit 9
  local ObjectType_All := -1;
  local ObjectType_Real := 0;
  local ObjectType_Integer := 1;
  local ObjectType_String := 2;
  local ObjectType_Complex := 3;
  local ObjectType_Matrix := 4;
  local ObjectType_Error := 5; 
  local ObjectType_List := 6;
  local ObjectType_SymbolicExpression := 8;
  local ObjectType_Unit := 9; 

  L1 := { 1.5, #FFFh, "X \"2\" Y", 3+4*i, "5", [[ 1, 3+4*i ],[ #FFFh, 3°05′06″ ]], { { 'Y=X^2', 'Y=2*X+3' },(5∡53), [ 3,4 ] }, 'X^2^Y^Z^W', 3_m, 3°05′06″, (3,4), "pi+3", 'X' };  
  if(
    input
    ( 
    {
    { L1(1), [ ObjectType_Real ] }, 
    { L1(2), [ ObjectType_Integer ] },
    { L1(3), [ ObjectType_String ] }, 
    { L1(4), [ ObjectType_Complex ] },  
    { L1(6), [ ObjectType_Matrix ] }, 
    { L1(7), [ ObjectType_List ] },
    { L1(8), [ ObjectType_SymbolicExpression ] },
    { L1(9), [ ObjectType_Unit ] },
    { L1(10), [ ObjectType_Real ] }, 
    { L1(11), [ ObjectType_Complex ] },
    { L1(12), [ ObjectType_All ] },
    { L1(13), [ ObjectType_SymbolicExpression, ObjectType_Real ] }  
    },
    { "Data Types page 1/2","Data Types page 2/2" },
    { "Real:", "Binary Integer:", "String:", "Complex:", "Matrix:", "List:", "SymExpr:", "Unit:", "Real (Angle)", "Complex (x,y)", "Any", "Real or SymbExpr" },
    {},
    { 5/3, #10h, char(64), (5∡53), [ e^1, pi/2 ], { {1, 2}, 5 mod 3 }, 'Y=X^2', 3.1_m, 3°, e^1, "e", 'Y' }

    )
   ) 
   then
  
    A:=L1(1);  
    B:=L1(2);
    strVar:=L1(3);
    Z1:=L1(4);
    M1:=L1(6);
    L2:=L1(7);
    L3:=L1(7,1);
    E1:=L3(1);
    E2:=L3(2);
    F1:=L1(8);
    unitVar:=L1(9);
    C:=L1(10);
    Z2:=L1(11);
    IFERR F2:=L1(12);
    THEN
    END;
    IFERR F3:=L1(13);
    THEN
    END;

    return(L1);
   end;
END;


//export xx := 7;
export inputv1a()
BEGIN
  // RECUPERARANDO EL ULTIMO VALOR ASIGNADO, se debe crear xx como 
  // variable global "export xx := 7;" antes de la definición de la función
  input( xx );
  return "xx: "+xx;
END;

export inputv1b()
BEGIN
  // RECUPERARANDO EL ULTIMO VALOR ASIGNADO sin usar el EXPORT CMD, 
  //también puede usarse variables de almacenamiento de números reales [A,B,...,Z, THETA] (EN MAYÚSCULAS) 
  // conocidas como "USER VARIABLES"  

  input( X );
  return "X: "+X;
END;

export CheckingKeystrokesInput()
begin
  local ok := true;
  local cancel := false;
  local keyPressedOnMenu := cancel;
  keyPressedOnMenu := input(X);
  if keyPressedOnMenu == ok then
    return X;
  else
    return "Done";
  end;
end;

//export xx := 7;
export inputv1c()
BEGIN
  // Agregando TÍTULO PERSONALIZADO, argumento #2
  input( xx, "titulo» Modificando xx" );
  return "xx: "+xx;
END;

//export xx := 7;
export inputv1d()
BEGIN
  // Agregando TÍTULO Y NOMBRE DE LA ETIQUETA PERSONALIZADA, argumentos #2-3
  input( xx, "titulo» Modificando xx", "etiqueta» xx:" );
  // note que la ayuda automáticamente elimina los dos puntos si los hay al final de la etiqueta 
  // mostrando solo "Enter value for etiqueta X" yy no "Enter value for etiqueta X:"
  return "xx: "+xx;
END;

//export xx := 7;
export inputv1e()
BEGIN
  // Agregando TÍTULO, ETIQUETA Y AYUDA PERSONALIZADA, argumentos #2-4
  input( xx, "titulo» Modificando xx","etiqueta» xx:","Ayuda» Ingrese valor para la etiqueta xx" );
  return "xx: "+xx;
END;

//export xx := 7;
export inputv1f()
BEGIN
  // agregando TITULO, ETIQUETA, AYUDA, Y VALOR DE REINICIO PERSONALIZADO, argumentos #2-5
  local valorDeReinicio := 5.1;
  input(
  xx,
  "titulo» Modificando xx",
  "etiqueta» xx:",
  "Ayuda» Ingrese valor para la etiqueta xx",
  valorDeReinicio
  );
  // el valor de reinicio se coloca con la secuencia [shift]+[esc] ó solo [backspace]
  //Resetting all the fields oprima [shift]+[clear]
  return "xx: "+xx;
END;

//export xx := 7;
export inputv1g()
BEGIN
  // agregando TÍTULO, ETIQUETA, AYUDA, VALOR DE REINICIO E INICIAL PERSONALIZADO, argumentos #2-5
  //xx := 5.2; // ya no es necesario definir un valor inicial en esta forma
  local valorDeReinicio := 5.1234;
  local valorInicial := 5.2;
  input(
  xx,
  "titulo» Modificando xx",
  "etiqueta» xx:",
  "Ayuda» Ingrese valor para la etiqueta xx",
  valorDeReinicio,
  valorInicial
  );
  return "xx: "+xx;
END;

//export xx := 7;
export inputv1h()
BEGIN
  // ARGUMENTOS POR DEFECTO se agrega {} y para campo vacío ""
  // {} para nombre de etiqueta por defecto yy ayuda vacía o sin texto
  input( xx, "titulo» Modificando xx", {}, "" ); 
  return "xx: "+xx;
END;

// II: INPUT con varias variables

//export xx := 7; export yy := 0; export zz := 0;
export inputv02()
BEGIN
  // para un CONJUNTO DE VARIABLES se abarcan entre {}
  input( { xx, yy, zz }, 
  "titulo» Modificando xx, yy, zz", "etiqueta» xx:", "Ayuda» Ingrese valor para la etiqueta xx" );
  // note que las cadenas de texto para etiqueta yy ayuda solo afectan a la primera variable
  return { "xx: "+xx, "yy: "+yy, "zz: "+zz };
END;

//export xx := 7; export yy := 0; export zz := 0;
export inputv2a()
BEGIN
  // para un CONJUNTO DE ETIQUETAS Y AYUDAS SE ABARCAN ENTRE {}
  input( { xx, yy, zz }, "titulo» Modificando xx, yy, zz",
  { "etiqueta» xx:", "etiqueta» zz:", "etiqueta» zz:" },
  { "Ayuda» Ingrese valor para la etiqueta xx", "Ayuda» Ingrese valor para la etiqueta yy", 
  "Ayuda» Ingrese valor para la etiqueta zz" }
  );
  return { "xx: "+xx, "yy: "+yy, "zz: "+zz };
END;

//export xx := 7; export yy := 0; export zz := 0;
export a := 4, b := 3, c := 2, d := 1, e1 := 0; 
export f := 10;
export inputv2b()
BEGIN
  // Si hay más de 7 variables LOS CAMPOS SE MUESTRAN EN N PANTALLAS
  input(
  { xx, yy, zz, a, b, c, d, e1, f },
  "titulo» modificando n variables",
  { "etiqueta» xx:", "etiqueta» yy:", "etiqueta» zz:" },
  { "Ayuda» Ingrese valor para la etiqueta xx", "Ayuda» Ingrese valor para la etiqueta yy", 
    "Ayuda» Ingrese valor para la etiqueta zz" }
  );
  // puede completar las cadenas de texto para las etiquetas yy ayuda para A,B,C,D,EE
  // con la tecla virtual [page #/#] se avanza ó REGRESA entre pantallas
  return { xx, yy, zz, a, b, c, d, e1, f };
END;

//export xx := 7; export yy := 0; export zz := 0;
//export a := 4, b := 3, c := 2, d := 1, e1 := 0; 
//export f := 10;
export inputv2c()
BEGIN
  // para un CONJUNTO DE TÍTULOS se abarcan entre {}
  input(
  { xx, yy, zz, a, b, c, d, e1, f },
  { "Titulo» modificando variables xx, yy, ... d", "titulo» modificando variable ee, f" },
  { "etiqueta» xx:", "etiqueta» yy:", "etiqueta» zz:" },
  { "Ayuda» Ingrese valor para la etiqueta xx", "Ayuda» Ingrese valor para la etiqueta yy", 
    "Ayuda» Ingrese valor para la etiqueta zz" }
  );
  return { xx, yy, zz, a, b, c, d, e1, f };
END;

// III: Variable con n elementos

export inputv03()
BEGIN
  // Variable con n elementos tipo LISTA
  local list1 := { 5, 4, 3, 2};
  input( {list1[ 1 ], list1[ 2 ], list1[ 3 ], list1[ 4 ]},
  "T» Mod los elementos de una lista",
  { "list[1]:", "list[2]:", "list[3]:", "list[4]:" }
  );
  return list1;
END;

export inputv3a()
BEGIN
  // Variable con n elementos tipo ARRAY
  local array1 := [[1,2],[3,4]];
  input(
  {
  array1[ 1,1 ],
  array1[ 1,2 ],
  array1[ 2,1 ],
  array1[ 1,2 ]
  },
  "T» Mod los elementos de un arreglo",
   { "M[1,1]:", "M[1,2]:", "M[2,1]:", "M[2,1]:" }
  );
  return array1;
END;

export inputv3b()
BEGIN
  // Variable con n elementos tipo CADENA DE CARACTERES
  local str1 := "abcdefgh";
  input(
  {
  str1[ 1 ],
  str1[ 2 ],
  str1[ 3 ],
  str1[ 4 ],
  str1[ 5 ],
  str1[ 6 ],
  str1[ 7 ]
  },
  "T» Mod los elementos de una cadena"
  );
  return str1;
END;

export inputv3c()
BEGIN
  // POSICIONANDO LOS CAMPOS DE ENTRADA ó 
  // desfasadolos xx% hacia la derecha, con x1% de ancho
  // tercer argumento entre llaves
  local offsetField0 := 0; //0%
  local offsetField5 := 5; //10%
  local offsetField10 := 10; //%
  local offsetField15 := 15; //%
  local offsetField20 := 20; //%
  local offsetField25 := 25; //%
  local offsetField30 := 30; //%
  local offsetField40 := 40; //%
  local offsetField45 := 45; //%
  local offsetField50 := 50; //%
  //...
  local offsetField100 := 100; //100%
  local widthField0 := 0; //0%
  local widthField10 := 10; //%
  local widthField15 := 15; //%
  local widthField20 := 20; //%
  local widthField25 := 25; //%
  local widthField30 := 30; //%
  local widthField40 := 40; //%
  local widthField50 := 50; //%
  // ...
  
  // page 1
  local lineField0 := 0;
  local lineField1 := 1;
  local lineField2 := 2;
  local lineField3 := 3;
  local lineField4 := 4;
  local lineField5 := 5;
  local lineField6 := 6;
  // page 2
  local lineField7 := 7;
  local lineField8 := 8;
  // ...
  
  local ObjectType_Real :=  0;
  local array1 := [[1,2],[3,4]];
  input(
  {
  { array1[1,1], [ ObjectType_Real ], { offsetField15, widthField15, lineField0 } },
  { array1[1,2], [ ObjectType_Real ], { offsetField15, widthField15, lineField1 } },
  { array1[2,1], [ ObjectType_Real ], { offsetField45, widthField15, lineField0 } },
  { array1[2,2], [ ObjectType_Real ], { offsetField45, widthField15, lineField1 } }
  },
  "T» Mod los elementos de un arreglo",
  { "M[1,1]:", "M[1,2]:", "M[2,1]:", "M[2,1]:" }
  );
  return array1;
END;

export inputcheckv04()
BEGIN
  // Seleccion de una dato por 
  local checkbox := 0;
  local checkbox_true := true;
  local checkbox_false := false;
  input(
  {
  { X, checkbox },
  { Y, checkbox }
  }
  );
  return [ X, Y ];
  // las teclas [±] ó [enter] ó [CHECK] cambian el estado de la casilla
END;


export inputcheckv4a()
BEGIN
  // AGRUPANDO CAMPOS, solo un campo se puede chulear
  local checkbox := 0;
  local checkbox_true := true;
  local checkbox_false := false;
  local group2_checkbox := 2;
  local group3_checkbox := 3;
  local group4_checkbox := 4;
  input(
  {
  { X,group2_checkbox },
  { Y,checkbox },
  { Z,checkbox },
  { W,checkbox }
  }
  );
  return [ X, Y, Z, W ];
END;

export posList := 2; // global
export inputDropDownv05()
BEGIN
  // Selección de una dato por menú desplegable
  local list1 := { 1, 2, 3, 4 };
  input( { { posList, list1 } },
  "Titulo» menú desplegable",
  "list"
  );
  return "opcion "+posList+": "+list1[posList];
END;

export inputIntroduction()
BEGIN
  // truco para mostrar una introducción
  
  local offsetField0 := 0; //0%
  local offsetField5 := 5; //10%
  local offsetField10 := 10; //%
  local offsetField15 := 15; //%
  local offsetField20 := 20; //%
  local offsetField25 := 25; //%
  local offsetField30 := 30; //%
  local offsetField40 := 40; //%
  local offsetField45 := 45; //%
  local offsetField50 := 50; //%
  //...
  local offsetField100 := 100; //100%
  local widthField0 := 0; //0%
  local widthField10 := 10; //%
  local widthField15 := 15; //%
  local widthField20 := 20; //%
  local widthField25 := 25; //%
  local widthField30 := 30; //%
  local widthField40 := 40; //%
  local widthField50 := 50; //%
  // ...
  
  // page 1
  local lineField0 := 0;
  local lineField1 := 1;
  local lineField2 := 2;
  local lineField3 := 3;
  local lineField4 := 4;
  local lineField5 := 5;
  local lineField6 := 6;
  // page 2
  local lineField7 := 7;
  local lineField8 := 8;
  // ...
  
  local ObjectType_Real  :=  0;
  local empty, xx := 2.5;
  input(
  {
  { empty, [ ObjectType_Real ], { offsetField100, widthField0, lineField0 } },
  { empty, [ ObjectType_Real ], { offsetField100, widthField0, lineField1 } },
  { empty, [ ObjectType_Real ], { offsetField100, widthField0, lineField2 } },
  { empty, [ ObjectType_Real ], { offsetField100, widthField0, lineField3 } },
  { empty, [ ObjectType_Real ], { offsetField100, widthField0, lineField4 } },
  { empty, [ ObjectType_Real ], { offsetField100, widthField0, lineField5 } },
  { empty, [ ObjectType_Real ], { offsetField100, widthField0, lineField6 } },
  { xx, [ ObjectType_Real ], { offsetField5, widthField20, lineField7 } }
  },
  { "Introduction at the first page", "Input" },
  { "HELLO on Line 1                         ", 
    "WORLD on Line 2                        ", 
    "AGAIN on Line 3                        ", 
    "", 
    "", 
    "", 
    "Press [Page 1/#] to continue                ", 
    "xx:"
   },
  { "", "", "", "", "", "", "", "Enter xx value" }
  );
  return "xx: "+xx;
END;


export resetFunctionAppVars( varApp_str )
BEGIN
  expr( "Function." + varApp_str + ":=0"); // "" = "No definition in Symbolic view"
  return "Done";
END;


#cas
  PRGCAS():= 
  BEGIN
    SetFunctionAppVars( "F1" );
    SetFunctionAppVars( "F2" );
    // ...
    return("Done");
  END;
#end

export SetFunctionAppVars( varApp_str )
BEGIN
  local symbExpr, resetVALUE_FX, initVALUE_FX;
  IFERR
    initVALUE_FX := EXPR( varApp_str );
  THEN
    initVALUE_FX := 0; // 
  END; 
  resetVALUE_FX := 'X^2/9';
  local ObjectType_SymbolicExpression := 8;
  if 
  (
    input( 
    { { symbExpr, [ ObjectType_SymbolicExpression ] } }, 
    "Set Function App Vars",
    varApp_str+"(X):",
    "Enter Symbolic Expression for "+varApp_str+"(X)",
    resetVALUE_FX, 
    initVALUE_FX
    )
  )
  then
    expr("Function." + varApp_str + ":='" + symbExpr + "'");
    //CAS( EVAL(varApp_str + "(X):=" + symbExpr) );
    //return( { varApp_str, symbExpr, varApp_str + "(X):=" + symbExpr,  varApp_str + ":='" + symbExpr + "'" });
  end;
END;



export testInputList2()
begin
  // usando las variables de USUARIO L0, ... L9
  //local L0, L1, ..., L9; // NO SE REQUIEREN ESTAS VARIABLES DEFINIRLAS COMO LOCALES
  local resetVAL_L1, resetVAL_L2;
  local initVAL_L1, initVAL_L2;

  L9 := { 0, 1 };  L8 := { 2 };
  L7 := { 3 };  L6 := { 4 };

  initVAL_L1 :=  L9; initVAL_L2 := L8;
  resetVAL_L1 := L7; resetVAL_L2 := L6;
 
  local ObjectType_List :=6;
  local ObjectType := ObjectType_List ; 
  local title := "Type Allow: List ";
  local ok := true;
  local cancel := false;
  local keyPressedOnMenu := cancel;

  keyPressedOnMenu := input
  (
  {
  { L1, [ ObjectType ] },
  { L2, [ ObjectType ] }
  },
  title,
  { "L1:=", "L2:="},
  { "Enter LIST1", "Enter LIST2"},
  { resetVAL_L1, resetVAL_L2 },
  { initVAL_L1, initVAL_L2 }
  );
  if keyPressedOnMenu == ok then
    return( { L1, L2 } );
  else
    return "Done";
  end;
end;

export testInputArray()
begin
  local a, b, c;
  local resetVAL_a, resetVAL_b, resetVAL_c;
  local initVAL_a, initVAL_b, initVAL_c;
  initVAL_a := [ 1 ]; initVAL_b := [ 2 ]; initVAL_c := [ 3 ]; 
  resetVAL_a := [ 0 ]; resetVAL_b := [ 0 ]; resetVAL_c := [ 0 ]; 
  local ObjectType_Matrix :=  4;
  local ObjectType := ObjectType_Matrix;
  local title := "Type Allow: Array [0]";
  local ok := true;
  local cancel := false;
  local keyPressedOnMenu := cancel;
  keyPressedOnMenu := input
  (
  {
  { a, [ ObjectType ] },
  { b, [ ObjectType ] },
  { c, [ ObjectType ] }
  },
  title,
  { "label_a:", "label_b:","label_c:" },
  { "help_a", "help_b", "help_c" },
  { resetVAL_a, resetVAL_b, resetVAL_c },
  { initVAL_a, initVAL_b, initVAL_c }
  );
  if keyPressedOnMenu == ok then
    return ({a, b, c});
  else
    return "Done";
  end;
end;

export testInputComplex()
begin
  local a, b, c;
  local resetVAL_a, resetVAL_b, resetVAL_c;
  local initVAL_a, initVAL_b, initVAL_c;
  initVAL_a := i; initVAL_b := (3,4); initVAL_c := 3+4*i;
  resetVAL_a := 0+0*i; resetVAL_b := 0+0*i; resetVAL_c := 0+0*i; 
  local ObjectType_Complex := 3;
  local ObjectType := ObjectType_Complex; 
  local title := "Type Allow: Complex a+b*i";
  local ok := true;
  local cancel := false;
  local keyPressedOnMenu := cancel;
  keyPressedOnMenu := input
  (
  {
  { a, [ ObjectType ] },
  { b, [ ObjectType ] },
  { c, [ ObjectType ] }
  },
  title,
  { "label_a:", "label_b:","label_c:" },
  { "help_a", "help_b", "help_c" },
  { resetVAL_a, resetVAL_b, resetVAL_c },
  { initVAL_a, initVAL_b, initVAL_c }
  );
  if keyPressedOnMenu == ok then
    return ({a, b, c});
  else
    return "Done";
  end;
end;


export testInputComplex2()
begin
  // VARIABLES Z0-Z9
  local a, b, c;
  local resetVAL_a, resetVAL_b, resetVAL_c;
  local initVAL_a, initVAL_b, initVAL_c;
  initVAL_a := i; initVAL_b := (3,4); initVAL_c := 3+4*i;
  resetVAL_a := 0+0*i; resetVAL_b := 0+0*i; resetVAL_c := 0+0*i; 
  local ObjectType_Complex := 3;
  local ObjectType := ObjectType_Complex; 
  local title := "Type Allow: Complex a+b*i";
  local ok := true;
  local cancel := false;
  local keyPressedOnMenu := cancel;
  keyPressedOnMenu := input
  (
  {
  { a, [ ObjectType ] },
  { b, [ ObjectType ] },
  { c, [ ObjectType ] }
  },
  title,
  { "label_a:", "label_b:","label_c:" },
  { "help_a", "help_b", "help_c" },
  { resetVAL_a, resetVAL_b, resetVAL_c },
  { initVAL_a, initVAL_b, initVAL_c }
  );
  if keyPressedOnMenu == ok then
    return ({a, b, c});
  else
    return "Done";
  end;
end;


export testInputString()
begin
  local a, b, c;
  local resetVAL_a, resetVAL_b, resetVAL_c;
  local initVAL_a, initVAL_b, initVAL_c;
  initVAL_a := "abc"; initVAL_b := "123"; initVAL_c := "\"X\""; 
  resetVAL_a := ""; resetVAL_b := ""; resetVAL_c := "";  
  local ObjectType_String := 2;
  local ObjectType := ObjectType_String; 
  local title := "Type Allow: String ";
  local ok := true;
  local cancel := false;
  local keyPressedOnMenu := cancel;
  keyPressedOnMenu := input
  (
  {
  { a, [ ObjectType ] },
  { b, [ ObjectType ] },
  { c, [ ObjectType ] }
  },
  title,
  { "label_a:", "label_b:","label_c:" },
  { "help_a", "help_b", "help_c" },
  { resetVAL_a, resetVAL_b, resetVAL_c },
  { initVAL_a, initVAL_b, initVAL_c }
  );
  if keyPressedOnMenu == ok then
    return ({a, b, c});
  else
    return "Done";
  end;
end;


export testInputSymbolic()
begin
  local FN1, FN2;
  local resetVAL_FN1, resetVAL_FN2;
  local initVAL_FN1, initVAL_FN2;

  initVAL_FN1 :=  'X^3-6*X^2+11*X-6'; initVAL_FN2 := 'X^2-3*X+2';
  resetVAL_FN1 := 'X^3-0*X^2+X'; resetVAL_FN2 := 'X^2-0*X+1';
 
  local ObjectType_Symbolic := 8;
  local ObjectType := ObjectType_Symbolic; 
  local title := "Type Allow: Symbolic";
  local ok := true;
  local cancel := false;
  local keyPressedOnMenu := cancel;

  keyPressedOnMenu := input
  (
  {
  { FN1, [ ObjectType ] },
  { FN2, [ ObjectType ] }
  },
  title,
  { "F1(X):=", "F2(X):="},
  { "Enter symbolic expression for F1", "Enter symbolic expression for F2"},
  { resetVAL_FN1, resetVAL_FN2 },
  { initVAL_FN1, initVAL_FN2 }
  );
  if keyPressedOnMenu == ok then
    return( { { Function.F1:=FN1, F2:=FN2 },{ csolve(F1,X), csolve(F2,X) } } ); // 1 2 3 - 1 2
  else
    return "Done";
  end;
end;


export TESTVARS()
begin
  PRINT();


  //USER VARS
  A := 1; B:=2;
  X := 5.9;
  L1 := {1,{2},"HELLO"};
  M1 := [[1,2,3],[4,5,6]];
  Z1 := 3+4*i;


  // APP VARS
  PRINT( "F(X) Function app user symbolic variables" );
  Function.F1 := 'X^3-6*X^2+11*X-6'; // OR F1 := 'X^3-6*X^2+11*X-6'; OR CAS("F3(X):=X^3-6*X^2+11*X-6"); or sto('X^3-6*X^2+11*X-6',F1);
  F2 := 'X^2-3*X+2';
  F0 := 'X^3-0*X^2+X';
  CAS("F3(X):=X^3");
  CAS("F4(X):=X^3-2");
  sto('X+5',F5);

  PRINT( "F1(X) = " + Function.F1 );
  PRINT( "F2(X) = " + Function.F2 );
  PRINT( "F3(X) = " + Function.F0 );
  PRINT( "" );


  PRINT( "V(X,Y) Advanced Graphing app user symbolic variables" );    
  V1 := 'X^2+Y^2 = 10';
  V2 := '2*X-3*Y = 6';
  V3 := 'Y MOD X = 3';
  Advanced_Graphing.V4 := Function.F1+'Y';


  PRINT( "V1(X,Y) = " + Advanced_Graphing.V1 );
  PRINT( "V2(X,Y) = " + Advanced_Graphing.V2 );
  PRINT( "V3(X,Y) = " + Advanced_Graphing.V3 );
  PRINT( "" );


  PRINT( "{ X(T), Y(T) } PARAMETRIC app user symbolic variables" ); 
  Y1 := 'SIN(4*T)';
  X1 := 'SIN(6*T)';
  PRINT( "{ X1(T) = " + Parametric.X1 + ", Y1(T) = " + Parametric.Y1 + " }" );
  PRINT( "" );

  PRINT( "R(THETHA) POLAR app user symbolic variables" );
  R1 := 'SIN(T)';
  PRINT( "R(T) = " + Polar.R1 );
  PRINT( "" );

  PRINT( "EQ() SOLVE app user symbolic variables" );
  E1 := 'X^2';
  E2 := '2*X+3';
  PRINT( "{ E1(X) = " + E1 + ", E2(X) = " + E2 + " }" );
  PRINT( "END" );

  //User Vars
  // {"A", "B", "X","L1","M1","Z1","F1","F2","F0","V1","V2","T"})

  //F(X) Function symbolic variables
  // { "F0","Function.F1","F1", "F2","F3","F4","F5","F6","F7","F8","F9" }

  // V(X,Y) Advanced Graphing symbolic variables 
  // { "V0","V1","V2","V3","V4","V5","V6","V7","V8","V9" }


  // { X(T), Y(T) } PARAMETRIC symbolic variables
  // { "X0","X1","X2","X3","X4","X5","X6","X7","X8","X9" }
  // { "Y0","Y1","Y2","Y3","Y4","Y5","Y6","Y7","Y8","Y9" } 

  //R(?) POLAR symbolic variables
  // { "R0","R1","R2","R3","R4","R5","R6","R7","R8","R9" }


  return "Done";
end; 


[compsystems]

Another even more difficult challenge, not only for hp-prime developers but also for experts in graphical interfaces, is printing in pretty-print (2D), I think the ti89 and ti-nspire series calculators are the only ones that print in 2D. This facilitates the visualization of results mathematical expressions.

HP-Prime 2015 firmware print versus TI-Basic print2D 1994 firmware