Working document

Greg Michaelson & Quintin Cutts

G.Michaelson@hw.ac.uk

Q.Cutts@glasgow.ac.uk

Contents

Evolution

• 
  to do
  
  • 
    explicit type signatures?
    
  • 
    side effects?
    
• 
  14/1/14
  
  • 
    ARRAY size clarified
    
  • 
    unknown size ARRAY variable definition
    
  • 
    corrected floating point definition
    
  • 
    “-“ no longer permitted in identifiers
    
  • 
    commands in condition/repetition bodies
    
  • 
    added draft OO
    
• 
  20/12/13
  
  • 
    OPEN, CLOSE, CREATE
    
  • 
    end of file
    
  • 
    reordered so GUI at end
    
• 
  9/9/13
  
  • 
    explicit type coercions
    
  • 
    comments
    
• 
  24/6/13
  
  • 
    SEQUENCE indices start at 0
    
  • 
    removed PROCEDURE/FUNCTION BEGIN
    
  • 
    added RETURN as last to be executed in PROC/FUNC
    
• 
  21/6/13
  
  • 
    added ^ exponent
    
  • 
    changed && to AND, || to OR, == to =, != to ≠
    
  • 
    changed examples at end to reflect previous changes
    

• 
  13/6/13
  
  • 
    added REF & VAL options for parameters
    

• 
  22/5/13
  
  • 
    added procedures & functions
    

• 
  18/3/13
  
  • 
    integer divide now explicitly rounds down
    
  • 
    mixed type arithmetic has explicit coercions
    
  • 
    introduced STRING append &
    

• 
  11/12/12
  
  • 
    rewritten to reflect National 5 document: SET/SEND/RECEIVE/END X
    
  • 
    revised GUI notation to reflect above changes
    
  • 
    added GUI example
    
  • 
    revised Derek/Quentin/Jeremy examples accordingly
    

Introduction

The design philosophy is that Haggis should:

• 
  not be based on any one extant programming language;
  
• 
  be easily translatable into and out of most programming languages used in Scottish schools;
  
• 
  be suitable for qualifications up to Advanced Higher/University first year, while also being amenable to sub-setting as appropriate for earlier year qualifications;
  
• 
  be intuitive (whatever that means...);
  
• 
  be succinct but relaxed about there being different ways of expressing the same thing;
  
• 
  be orthogonal, that is unitary constructs should have meanings in different contexts;
  
• 
  not expose conceptual details if they are not germane.
  

Types

The base types and their values are:

• 
  INTEGER: -big ... + big – where big is arbitrary
  
• 
  REAL: -big.small ... + big.small – where big and small are arbitrary
  
  • 
    floating point notation is also fine: +/- big₁.smallEbig₂ == big₁.small times 10 to the power big₂
    
• 
  BOOLEAN: true & false
  
• 
  CHARACTER: ‘character’
  

• 
  SEQUENCE: arbitrary length sequence of values of arbitrary type
  

This encompasses:

• 
  ARRAY: finite length sequence of same type
  
• 
  STRING: ARRAY of CHARACTER
  
• 
  TUPLE : finite length sequence of different type
  
• 
  RECORD: finite length sequence of different type with named fiields
  
• 
  STREAM: SEQUENCE of CHARACTER
  
  • 
    this encompasses FILE & URL
    

• 
  ARRAY: [value,...]
  
• 
  TUPLE: (value,...)
  
• 
  RECORD: (name=value,...)
  
• 
  STRING: “character character...” == [‘character’,’character’,...]
  

The GUI types are:

• 
  WINDOW: SEQUENCE of GUI types with implicit IMAGE
  
• 
  LABEL: displays STRING
  
• 
  BUTTON: causes EVENT
  
• 
  TEXTBOX: returns STRING
  
• 
  MENU: SEQUENCE of BUTTON or MENU
  
• 
  IMAGE: with means of extracting/changing sub-images and drawing graphics
  

System entities

• 
  DISPLAY: in effect the default WINDOW
  
• 
  KEYBOARD: in effect the default TEXTBOX
  
• 
  MOUSE: with means of determining movement & button clicks
  
• 
  TIME: with means of extracting date/time information from year to milli-second
  

Identifiers

Variable introduction

• 
  VAR id – unknown type
  
• 
  VAR id [size] – ARRAY of unknown type & known size
  
• 
  type id – id can only be associated with type values
  
• 
  type id [size] – ARRAY of known type & size
  
• 
  VAR [] id – ARRAY of unknown type & size
  
• 
  size type id [] – ARRAY of known type & unknown size
  

Variables may be introduced implicitly by first use on the left of an assignment:

• 
  SET id TO value – introduces id of same type as, and initialised to, value
  
  • 
    includes initialisation of structured types
    

Commands

• 
  assignment
  
• 
  command sequences
  
• 
  blocks
  
• 
  parallelism
  
• 
  conditions
  
• 
  repetitions
  
• 
  iterations
  
• 
  sub-program calls
  

Assignment

• 
  assignment i.e. change value associated with id to that of expression
  
  • 
    see above for type implications
    

Command sequences

Command sequences may be made explicit on one line with “;” as a separator, not a terminator.

Blocks

Blocks determine the scope and extent of any variables they introduce.

Parallelism

• 
  executed commands simultaneously
  

Condition

IF expression THEN commands ELSE command END IF

WHEN expression DO commands END WHEN

• 
  expression evaluates to an EVENT
  
• 
  in PARALLEL, END WHEN may be omitted before AND and END PARALLEL
  

Repetition

• 
  never terminates
  

WHILE/UNTIL expression DO commands END WHILE

• 
  DO may be omitted if commands is indented
  

Iteration

FOR id FROM expression₁ TO expression2 STEP expression₃ DO command END FOR

FOR EACH id FROM expression DO commands END FOR EACH

• 
  expression returns a structured value
  
• 
  the order of value extraction form the value is probably first to last
  

Operations

• 
  minus: - unary
  
• 
  add: +
  
• 
  subtract: -
  
• 
  multiply: *
  
• 
  divide: /
  
• 
  exponent: ^
  

In addition, INTEGER has:

• 
  modulo: mod
  

• 
  equality: =
  
• 
  inequality: ≠ (or !=)
  
• 
  less than: <
  
• 
  less than or equal: <=
  
• 
  greater than: >
  
• 
  greater than or equal: >=
  

Order comparisons on structured types imply alphabetic order or equivalent.

The logical operators are:

• 
  conjunction: AND
  
• 
  disjunction: OR
  
• 
  negation: NOT
  

All structured types have the operator:

append: &

STRING append with mixed types coerces non-STRINGs to STRING representation.

Coercions

(INTEGER) coercing a real value will round that value down to the nearest integer.

Selection

Fields of RECORD types may be accessed by: id.name

Comment

Elision

I/O

• 
  input next value from source to id
  
• 
  source may be:
  
  • 
    KEYBOARD
    
  • 
    id associated with TEXTBOX
    
  • 
    file path
    
• 
  first access to file source opens file
  
• 
  source may be preceded by a coercion (type)
  

• 
  append value of expression in standard form to target
  
• 
  target may be:
  
  • 
    DISPLAY
    
  • 
    id associated withLABEL or BUTTON
    
  • 
    file path
    
• 
  first access to file target creates new file
  

• 
  returns true if file associated with path is empty
  

OPEN path

• 
  opens extant file associated with path for input or output by context of use
  

• 
  creates new file associated with path
  
• 
  new file replaces any extant file
  
• 
  does not open file
  

• 
  closes file associated with path
  

OPEN path

process using path

CLOSE path

A typical sequence for a new file would be:

CREATE path

OPEN path

process using path

CLOSE path

Note that the string for a path may be associated with a variable and that variable used in I/O i.e.

SET id TO path

RECEIVE ... FROM id/SEND ... TO id

OPEN/CREATE/CLOSE id

...empty(id)...

Sub-programs

• 
  procedure: control abstraction
  
• 
  function: expression abstraction
  

PROCEDURE id()

END PROCEDURE

and parameter-less function definitions have the form:

FUNCTION id()

...

END FUNCTION

RETURN expression

Parameter-less procedures and functions are called by:

id()

in control and expression contexts respectively.

For a function call, it is implicit that the return expression should have a type which is consistent with the calling context.

For functions, the definition may be optionally preceded by the return type:

...

so the return expression must have that type.

For procedures and functions with parameters, the identifier is followed by a sequence of comma separated formal parameter identifiers:

PROCEDURE id(id₁,id₂,...id_N)

...

FUNCTION id(id₁,id₂,...id_N)

It is a Haggis convention that occurrences of formal parameters in procedure and function bodies should be in italics, or underlined in non-digital media.

Procedures and functions with parameters are called by:

id(exp₁,exp₂,...exp_N)

It is implicit that the actual parameter exp_i has the same type as the formal parameter id_i.

Formal parameters may be optionally preceded by their types:

PROCEDURE id(type₁ id₁,type₂ id₂,...type_N id_N)

...

FUNCTION id(type₁ id₁,type₂ id₂,...type_N id_N)

No assumptions are made about the mode of parameter passing. However, formal parameters may also be optionally preceded by:

• 
  REF – call by reference
  
• 
  VAL – call by value
  

Object Orientation

CLASS id [INHERITS id]

...

END CLASS

Classes may contain:

• 
  variable introduction –fields
  
• 
  procedure/function definitions –methods
  
• 
  constructor definitions:
  

...

A class id may appear anywhere that type may appear.

New instances of objects are constructed by:

CONSTRUCT id(exp₁,exp₂,...exp_N)

There are implicit constructors for SEQUENCE types:

e.g. INT x[];

SET x TO CONSTRUCT INT[23];

Fields of objects are selected by:

Methods of objects are invoked by:

For example:

CLASS stack

INT sp;

INT s[];

SET SP TO 0;

SET MAx to n;

SET s TO CONSTRUCT INT[n];

END CONSTRUCTOR

PROCEDURE push(INT v)

IF sp=MAX THEN

SEND “stack overflow” TO DISPLAY

ELSE

SET s[sp] TO v;

END PROCEDURE

INT FUNCTION pop()

IF sp=0 THEN

SEND “stack underflow” TO DISPLAY

RETURN 0;

ELSE

SET sp TO sp-1;

END FUNCTION

END CLASS

The object oriented form:

has the procedural equivalent:

Graphics

Generic commands include:

• 
  clear() – clear drawing area
  
• 
  lineWidth(integer)
  

• 
  penUp()
  
• 
  penDown()
  
• 
  penHome() – sets pen facing north
  
• 
  penRotate(+/-degrees)
  
• 
  penMove(distance)
  
• 
  penColour(colour)
  
• 
  etc
  

• 
  line(x1,y1,x2,y2)
  
• 
  drawColour(colour)
  
• 
  fillColour(colour)
  
• 
  drawRectangle(x,y,height,length)
  
• 
  drawCircle(x,y,radius)
  
• 
  etc
  

GUI

Constructs are implicitly resized sensibly as they are added to a WINDOW.

ADD id₁ TO id₂

• 
  add GUI element associated with id₁ as next row of WINDOW associated with id₂
  

• 
  [...] specifies a column of GUI constructs
  
• 
  so each construct in [...] added on next row of WINDOW associated with id
  

• 
  nested [..] specifies a row of GUI constructs
  
• 
  so each constructs in nested [...] added along same row
  

• 
  inner [...] specifies a sub-column on a row
  

NB DISPLAY is default WINDOW so after adding elements to DISPLAY don’t need to use nominate “DISPLAY.” explicitly

NB KEYBOARD is an implicit TEXTBOX shared by all WINDOWs.

Grid GUI

WINDOW id[r]

• 
  id has integer r rows of same size
  

• 
  id has integer r rows of integer c columns
  

Choices

a)

BUTTON stop

b)

BUTTON stop(“STOP”)

BUTTON stop

stop.setText(“STOP”)

Not mutually exclusive...

Generalised problem is notation for changing arbitrary GUI construct properties:

• 
  size
  
• 
  colour
  
• 
  font
  
• 
  visibility
  
• 
  enabled
  

GUI Example 1

WINDOW w

SET title to “COUNTER”

LABEL counter

SET counter TO 0

BUTTON plus

SET plus to “+”

BUTTON reset

SET reset TO “RESET”

ADD [title,counter,[plus,reset]] TO w

PARALLEL

SET counter TO counter+1

AND

WHEN reset.clicked() DO

END PARALLEL

GUI Example 2

1

3

4

6

7

9

CLEAR

0

LABEL padDisplay

BUTTON keys[3][3]

BUTTON clear, zero, enter

SET padDisplay TO 0

FOR i FROM 0 TO 2

FOR j FROM 0 TO 2

SET keys[i][j] TO 3*i+j+1

END FOR

END FOR

SET zero TO 0

SET enter TO “ENTER”

SET c TO [padDisplay,keys,[clear,zero,enter]]

PARALLEL

WHEN keys[i][j] DO

SET padDisplay TO 10*padDisplay+2* i+j+1

AND

SET padDisplay TO 10*padDisplay

AND

WHEN clear DO

AND

SEND padDisplay TO DISPLAY

END PARALLEL

Derek Middleton SQA Exam Examples

lower TO

higher TO

FOR counter FROM lower TO upper DO

SET temp TO distance[counter]

SET distance[counter] TO distance[upper-counter]

SET distance[upper-counter] TO temp

END FOR

SET lower TO

SET upper TO

REPEAT

IF search_value>list[middle] THEN

SET lower TO middle+1

ELSE

END IF

END REPEAT

IF search_value=list[middle] THEN

SEND [“Search item was found at”,middle] TO DISPLAY

ELSE

SEND “Search item is not in list” TO DISPLAY

AH 2009