Skip to content

6.7 Data Structures

Jump to bottom
Claude Roux edited this page Sep 23, 2022 · 4 revisions

Creating and Handling Data Types in LispE through Pattern Matching Functions

Version française

LispE provides a way to handle data structures through functional data type definition.

Data Types

A data type in LispE is created with the keyword: data followed with a list of descriptors:

; Basic data types
(data (D1 p1 p2 ...) (D2 p1 p2 ...) (D3 p1 p2...) ...)

; Group of data type identified with 'name'
(data name (D1 p1 p2 ...) (D2 p1 p2 ...) (D3 p1 p2...) ...)

Each descriptor Dd is an atom followed with a list of parameters.

You can optionally add a name to a group of data type definitions.

Example:

; Some basic data types
(data (Point _ _) (Circle _ ) (Rectangle _ _) )

; We create a Shape, which is either a Triangle or a Square
(data Shape (Triangle _ _ _) (Square _))

We use '_' as a placeholder when the parameter type is irrelevant.

Note '_' is actually an alias for nil. Hence, you can replace this description with:

(data (Point nil nil) (Circle nil ) (Rectangle nil nil) )

We use '_' as a bit of a tradition in this case.

Visual cue: []

As a side note, since parentheses are a bit too many in these contexts, you can replace them with [] if you wish. This is also true for pattern functions. Hence, you can replace the above definitions with:

; Some basic data types
(data [Point _ _] [Circle _] [Rectangle _ _] )

; We create a Shape, which is either a Triangle or a Square
(data Shape [Triangle _ _ _] [Square _])

This notation does not change the semantics of these definitions, however it acts as a visual cue and makes the code more readable. Note that if you open with a [ you have to close with a ].

Creation

The creation of an instance is very simple. You simply implement a list that contains your data type name with its arguments. LispE checks then if the structure matches its definition.

(setq v (Point 10 20))

(setq v (Point 10)) 
; --> Error: Size mismatch between argument list and data type definition

Types

It is actually possible to put a constraint on the placeholders. LispE already provides the following list of basic types:

  • atom_
  • data_
  • dictionary_
  • dictionary_i_
  • dictionary_n_
  • float_
  • floats_
  • heap_
  • integer_
  • integers_
  • list_
  • llist_
  • matrix_
  • matrix_float
  • number_
  • numbers_
  • set_
  • set_i_
  • set_n_
  • set_s_
  • short_
  • shorts_
  • string_
  • strings_
  • tensor_
  • tensor_float_

In that case, you can force the arguments to be of a certain type. For instance, you might force Point to only accept integers.

(data [Point integer_ integer_])

If you try to create a data type that does not match, an error will be sent back.

(setq v (Point 10 'test)) 

; yields: Error: mismatch on data structure argument: 2 (integer_ required)

Of course, you can define nested definitions:

(data [Point _ _] [Circle [Point _ _] _] [Rectangle (Point _ _) _ _] )

which will be again enforced by LispE.

Clone this wiki locally