Scolring - Forum

fun build() =
	strbuild ("harry"::"john"::"joe"::nil)::("sally"::"jenny"::"mary"::nil)::("maria"::"julia"::"fredonia"::nil)::nil;; 
	
fun main()=
	_showconsole; 
	
	let strextr build-> llist in
	let hd llist -> text in 
	let hd (tl llist) -> secondline in
	(
		
	_fooS strcat "the result of the command strbuild is (\"harry\"::\"john\"::\"joe\"::nil)::(\"sally\"::\"jenny\"::\"mary\"::nil)::(\"maria\"::\"julia\"::\"fredonia\"::nil)::nil; is a string, and this is the string: " build;
	_fooS "strextr takes a string of the format above, and whenever it encounters a string like (\"harry\"::\"john\"::\"joe\"::nil), it converts that substring into a list of words.  So strextr returns a list of lists, where each list is a list of words such as (\"harry\"::\"john\"::\"joe\"::nil). There is no scol function that displays a list of lists to the console so you have to break up the return value of strextr into parts, each of which is a list of strings, which you can print to the console using _fooSList. So the head of the list returned by strextr is itself a list, which can be written to the console using _fooSList, as below:\n ";
	_fooSList  text;
	_fooS "\n \n you can show the next line, which is the next list in the list of lists, as the head of the tail of the list of lists returned by strextr, as below: \n" ;
 	_fooSList secondline;
	_fooS " \n \n  to show the end of the list of lists returned by strext where you have three lines (which is three lists of strings followed by nil), which is the value \"nil\", you have to find the head of the tail of the tail of the tail of the list, which itself is a list of one item, which is always \"nil\"  \n  when you have a list containing a list of lists, it's easier to do a recursive function to shrink the tail of the list so you are not dealing with tails of tails of tails of tails of tails ad infinitu. Below is the head of the tail of the tail of the tail of list where the list has three lines, followed by the last list, which is just a stub, nil";
	_fooSList  (hd (tl( tl (tl llist))));
	);
	0;;
	

//this is the pseudo parent of all the classes in this example

struct Animal =[

ihasbackbone:		I, //0 no backbone, 1 backbone
idiet:				I, //0 for vegetarian, 1 for carnivore, 2 for omnivore
ibiome:				I, //0 water, 1 land, 2 air
imulticellular:	I,//0 unicellular, 1 colonial like dcoral, 2 multicellular
igender:				I,//0 hermaphrodite, 1 female, 2 male
ilegs:				I, //0 for none, interger for amount of legs
sname:				S //every animal has a name!
	
	
	]mkAnimal;;
	
//pseudo subclass of Animal	
struct Invertebrate= [
	pclassanimal:		Animal,//parent type of Invertebrate which inherits all properties and functions
	ishelltype:			I //0 no shell, 1 outer shell, 2 vestigial inner shell like a squid
	]mkInvertebrate;;
//pseudo subclass of Invertebrate		
struct Mollusc =[
	pclassInvertebrate:	Invertebrate,
	imollusctype:			I //0 for relatively stationary like clam or mussel, 1 for octopid like octopus, squid, or nautilous
	]mkMollusc;;	
	
	
//create an interface that can accept different objects and process them differently, each object must call a function that returns the constructer that allows the object to be referenced by the interface
	
typedef InterfaceAnimal_Interface = 	
Animal_interface Animal
|
Invertebrate_interface Invertebrate
|
Mollusc_interface Mollusc
|
Other_animal_interface;;

//allow an Animal type object to be a object that implements(?) the InterfaceAnimal_Interface 
fun animal_plug_into_Animal_interface(panimal)=
	Animal_interface panimal;;


fun invertebrate_plug_into_Animal_interface(pInvertebrate)=
	Invertebrate_interface pInvertebrate;;

fun mollusc_plug_into_Animal_interface(pmollusc)=
	Mollusc_interface pmollusc;;

fun invertebrate_dispatcher (pinvertebrate)=
	_fooS "printing an invertebrate fields from  the InterfaceAnimal_Interface";
	_fooS strcat "the name of this invertebrate is " pinvertebrate.pclassanimal.sname;;
	
	
fun printanimalinformation(panimalinterfaceobject)=
	match panimalinterfaceobject with
	(Animal_interface tanimal -> _fooS  "this is an animal or some type of animal")
|
//extract Invertebrate object from  InterfaceAnimal_Interface and send the resulting Invertbrate to a function...I don't see any practical use for this, but it shows you can plug an Invertebrate into the  InterfaceAnimal_Interface and extract an Invertbrate from the  InterfaceAnimal_Interface
	(Invertebrate_interface tInvertebrate -> invertebrate_dispatcher tInvertebrate)
|

	(Mollusc_interface tmollusc -> _fooS "this is an animal and also an invetebrate and also a mollusc or some type of mollusc")
|	
(_ ->  _fooS "this is not an animal, it's a vegetable or mineral");;


// make an animal and set its properties
fun initAnimal(pbackbone, pdiet, pbiome, pmulticellualr, pgender, plegs, pname)=
	
let 	mkAnimal [pbackbone pdiet pbiome pmulticellualr pgender plegs pname]-> lanimal in
(
printanimalinformation (animal_plug_into_Animal_interface lanimal);
lanimal;
);;

// make an Invertebrate and set its properties
fun initInvertebrate(panimal, pshelltype)=
	let mkInvertebrate [panimal pshelltype]-> linvertebrate in
	(
		printanimalinformation (invertebrate_plug_into_Animal_interface linvertebrate);
		linvertebrate;
		
	);; 

	
	
// make an Mollusc and set its properties
fun initMollusc(pinvertebrate, pmollusctype)=
	let mkMollusc [pinvertebrate pmollusctype]-> lmollusc in
	
	(
	printanimalinformation (mollusc_plug_into_Animal_interface lmollusc);
	lmollusc;
	);;

//make a new  mollusc, we know its name, its type of environment, what it eats, how many legs it has, and its mollusc subtype
//some of the arguments will help construct parent objects, and one of them (mollusc subtype) will determine what kind of mollusc it is
//mollusc name, mollusc biome, mollusc diet, mollusc leg amount, invertebrate parent, mollusc subtype
//this function displays the mollusc's properties, including properties of its parent types, and returns a mollusc type since that's the last statement in the function
//i put p in front of each argument, to stand for "pass" as in passing a variable to the function i put l in front of the objects create, since they are local objects, or temporary objects, so i guess after executing the function all that you are left with is its return value, which can be used in other functions, and i guess if it isn't used in other functions, the return value is destroyed after the function is execute too(?)
fun new_mollusc (pname, pbiome, pdiet, plegs, pinvertebrate, pmollusctype)= 
_fooS "\n";
//initAnimal backbone type, diet type, biome type, multiceullartype, gender, amount of legs, and name
	let initAnimal 0 pdiet pbiome  2 0 plegs pname -> lanimal in
//initInvertebrate animal parent class, shell type
	let initInvertebrate lanimal 1 -> linvertebrate in
//initMollusc, invertebrate parent class, mollusc subtype
	let initMollusc linvertebrate pmollusctype -> lmollusc in
	(
	_fooS "making a mollusc";
	_fooS strcat "the mollusc's name is " lmollusc.pclassInvertebrate.pclassanimal.sname;
	_fooS strcat "the mollusc's amount of legs is " (itoa lmollusc.pclassInvertebrate.pclassanimal.ilegs);
	
	
	if (lmollusc.pclassInvertebrate.pclassanimal.idiet == 0) then
	(
	_fooS "this mollusc is a vegetarian";
	)
	else if (lmollusc.pclassInvertebrate.pclassanimal.idiet == 1) then
	(
	_fooS "this mollusc is a carnivore";
	)
	else
	(
	_fooS "since this mollusc doesn't eat just plants or just animals, but has to eat something, because that's what animals do, it's an omnivore.";
	);

	
	
	if (lmollusc.imollusctype == 0) then
	(
	_fooS  "the mollusc doesn't swim alot";
	)
	else
	(
	_fooS  "the mollusc swims all over";
	);


	if (lmollusc.pclassInvertebrate.pclassanimal.ibiome == 0) then
	(
		_fooS "this mollusc lives in the water";
	)
	else
	(
		_fooS "this mollusc lives on land, or maybe is a new type of mollusc that flies through the air!";
	);
	
	lmollusc;
	);;
	
	



	
	fun main()=
		_showconsole; 
		//make a new  mollusc, like a clam or mussel, we know its name, its type of environment, what it eats, how many legs it has, and its mollusc subtype
		//mollusc name, mollusc biome, mollusc diet, mollusc leg amount, invertebrate parent, mollusc subtype
		new_mollusc "clam" 0 2 0 nil 0;
		//this verifies that the function new_mollusc in fact returns a mollusc that we can use
		let new_mollusc "nautilus" 0 1 50 nil 1 -> testmollusc in
		_fooS  strcatn "testing new mollusc function return value"::"this is a mollusc because it has the property named imollusctype and the value of the imollusctype is ":: (itoa testmollusc.imollusctype)::nil;;

customobject.custommethod();

struct   Cylinder =[
	Fradius			: F,
	Fheight			: F,
	funreturnheightasintergerasstring: fun[Cylinder] S,
	funreturnarea	:	fun [Cylinder] F,
	funreturnvolume:	fun[Cylinder] F
	
	]mkCylinder;;
	
	
fun returnheight(dcylinder)=
	let ftoi dcylinder.Fheight -> height in
itoa height;;
	


fun return_area_function(dyclinder)=
	let dyclinder.Fradius *. PIf-> result in
	 result;;

fun return_volune_function(dyclinder)=
	let return_area_function dyclinder-> area in
	area *. dyclinder.Fheight;;
	 
fun initcylinder(radius, height, returnheightfunction, returnareafunction, returnvolumefunction)=
	_fooS "initializing cylinder";
	mkCylinder [radius height returnheightfunction returnareafunction returnvolumefunction];;
		
fun copy_this_cylinder(dcylinder)=
     initcylinder dcylinder.Fradius dcylinder.Fheight dcylinder.funreturnheightasintergerasstring dcylinder.funreturnarea dcylinder.funreturnvolume;;

fun main()=
	_showconsole; 
	let initcylinder 102.0 19.087 @returnheight @return_area_function @return_volune_function -> dcylinder in
	(
	_fooS strcatn  "the height of the cylinder as a float converted to an interger converted to a string is " :: (returnheight dcylinder) :: nil;
	_fooS strcatn "the area taken up by the cylinder is ":: (ftoa (return_area_function dcylinder)):: " square meters."::nil; 
	_fooS strcatn "the volume taken up by the cylinder is " ::(ftoa (return_volune_function dcylinder)):: " cubic meters"::nil; 
	let copy_this_cylinder dcylinder-> new_cylinder in
		(
		   _fooS "creating new cylinder and changing radius from 102.0 to 10.5 with copy_this_cylinder (dcylinder) function";
			set new_cylinder.Fradius= 10.5;
			_fooS strcat "the radius of the copied cylinder is" ftoa new_cylinder.Fradius;
		);
	);
	0;;
 
	
	
 

var henry = new Cylinder(Robert);

dim henry = new Cylinder (Robert)