Hi there,

I am not very familiar with the type system of Common Lisp. Here is a
snippet of Pascal code to declare the type of a variable. How to do the
same thing in Common Lisp?

Code in Pascal:
type ASCIIcode=0..255;
xord:array[char]of ASCIIcode;
xchr:array[ASCIIcode]of char;

for me, the type ASCIIcode is a subrange of the integers. And xord and
xchr are two array with the type of ASCIIcode and char.

I don't know how to translate them into Common Lisp in a elegant style.

Thanks a lot in advance.

Best,
Jinsong

Jinsong Zhao <jszhao@yeah.net> writes:

> I am not very familiar with the type system of Common Lisp.

Searching the web for

"common lisp" cookbook types

should list a page in top position that will get you started.

Axel

On Thu, 17 Feb 2022 17:44:21 +0800
Jinsong Zhao <jszhao@yeah.net> wrote:
> Hi there,
>
> I am not very familiar with the type system of Common Lisp. Here is a
> snippet of Pascal code to declare the type of a variable. How to do the
> same thing in Common Lisp?

Pascal is statically typed whereas CL is dynamically typed. Furthermore
in CL if you declare an object to be of some type and then you assign
to it a value not of that type , it's undefined behaviour. So it is
uncertain what your expectations are when you say "same thing". But to
get you started...

> Code in Pascal:
> type ASCIIcode=0..255;

(deftype ASCIIcode () '(integer 0 255))
(deftype ASCIIcode2 () '(unsigned-byte 8))

Either one of these describe the same thing.

(let ((a 12))
(declare (type ASCIIcode a))
a)

Returns 12.

(let ((a 256))
(declare (type ASCIIcode a))
a)

Undefined behaviour. SBCL signals a condition , clisp returns 256. Both
behaviours are conforming as indeed any behaviour would be.

(let ((a 12))
(declare (type ASCIIcode2 a))
a)

Returns 12.

(let ((a 256))
(declare (type ASCIIcode2 a))
a)

Undefined behaviour. SBCL signals a condition , clisp returns 256.

> xord:array[char]of ASCIIcode;
> xchr:array[ASCIIcode]of char;

I am guessing that the second declaration says that xchr is a vector
[arrays of dimension 1 are called vectors in CL] where the index is
of type ASCIIcode [so takes values from 0 to 255] and each element
is of type char .The best approximation I could come up with which
works on SBCL is

(let ((vec (make-sequence 'vector 256 :initial-element #\a)))
(declare (type (vector t 256) vec)) ; This is the declaration you want
vec)

or

(let ((vec (coerce (make-sequence 'vector 256 :initial-element #\a)
'(vector character))))
(declare (type (vector character 256) vec)) ; This is the
; declaration you want
vec)

..But

(let ((vec (make-sequence 'vector 256 :initial-element #\a)))
(declare (type (vector character 256) vec))
vec)

causes SBCL to complain

The value #(#\a #\a #\a #\a #\a #\a #\a #\a #\a #\a #\a #\a ...)
is not of type
(VECTOR CHARACTER 256).

which puzzles me. But hopefully I have given you enough to get you started.

xord is a vector where each element is of type ASCIIcode but what
are the possible indexes ?

> for me, the type ASCIIcode is a subrange of the integers. And xord and
> xchr are two array with the type of ASCIIcode and char.

Not clear enough.

> I don't know how to translate them into Common Lisp in a elegant style.

--
vlaho.ninja/prog

On Thursday, February 17, 2022 at 9:49:52 AM UTC-8, Spiros Bousbouras wrote:
> On Thu, 17 Feb 2022 17:44:21 +0800
> Jinsong Zhao <jsz...@yeah.net> wrote:
> > Hi there,
> >
> > I am not very familiar with the type system of Common Lisp. Here is a
> > snippet of Pascal code to declare the type of a variable. How to do the
> > same thing in Common Lisp?
> Pascal is statically typed whereas CL is dynamically typed. Furthermore
> in CL if you declare an object to be of some type and then you assign
> to it a value not of that type , it's undefined behaviour. So it is
> uncertain what your expectations are when you say "same thing". But to
> get you started...
> [Snip]

One of the big differences between CL and most other typed languages is
that the declarations of types
(declare (type x (integer 0 255)))
is a *promise* to the compiler. You as the programmer are promising that
the variable X will have the indicated type. This is something that the compiler
is *not* required to check and is also *not* required to generate a run-time
error.

If you want to ensure that a variable has a particular type, you need to use
the CHECK-TYPE macro:
(check-type x (integer 0 255))
which will throw an error if the type check fails.

On 2022/2/17 19:15, Axel Reichert wrote:
> Jinsong Zhao <jszhao@yeah.net> writes:
>
>> I am not very familiar with the type system of Common Lisp.
>
> Searching the web for
>
> "common lisp" cookbook types
>
> should list a page in top position that will get you started.
>
> Axel

Thanks for the hint. I got the start point at:
https://lispcookbook.github.io/cl-cookbook/type.html

On 2022/2/18 1:49, Spiros Bousbouras wrote:
> On Thu, 17 Feb 2022 17:44:21 +0800
> Jinsong Zhao <jszhao@yeah.net> wrote:
>> Hi there,
>>
>> I am not very familiar with the type system of Common Lisp. Here is a
>> snippet of Pascal code to declare the type of a variable. How to do the
>> same thing in Common Lisp?
>
> Pascal is statically typed whereas CL is dynamically typed. Furthermore
> in CL if you declare an object to be of some type and then you assign
> to it a value not of that type , it's undefined behaviour. So it is
> uncertain what your expectations are when you say "same thing". But to
> get you started...
>
>> Code in Pascal:
>> type ASCIIcode=0..255;
>
> (deftype ASCIIcode () '(integer 0 255))
> (deftype ASCIIcode2 () '(unsigned-byte 8))
>
> Either one of these describe the same thing.
>
> (let ((a 12))
> (declare (type ASCIIcode a))
> a)
>
> Returns 12.
>
> (let ((a 256))
> (declare (type ASCIIcode a))
> a)
>
> Undefined behaviour. SBCL signals a condition , clisp returns 256. Both
> behaviours are conforming as indeed any behaviour would be.
>
> (let ((a 12))
> (declare (type ASCIIcode2 a))
> a)
>
> Returns 12.
>
> (let ((a 256))
> (declare (type ASCIIcode2 a))
> a)
>
> Undefined behaviour. SBCL signals a condition , clisp returns 256.
>
>> xord:array[char]of ASCIIcode;
>> xchr:array[ASCIIcode]of char;
>
> I am guessing that the second declaration says that xchr is a vector
> [arrays of dimension 1 are called vectors in CL] where the index is
> of type ASCIIcode [so takes values from 0 to 255] and each element
> is of type char .The best approximation I could come up with which
> works on SBCL is
>
> (let ((vec (make-sequence 'vector 256 :initial-element #\a)))
> (declare (type (vector t 256) vec)) ; This is the declaration you want
> vec)
>
> or
>
> (let ((vec (coerce (make-sequence 'vector 256 :initial-element #\a)
> '(vector character))))
> (declare (type (vector character 256) vec)) ; This is the
> ; declaration you want
> vec)
>

Thanks a lot for the above demo codes and explanation. It helps.

code:
(coerce (make-sequence 'vector 256 :initial-element #\a)
'(vector character))
could be simplified to:
(make-sequence '(vector character) 256 :initial-element #\a)

> .But
>
> (let ((vec (make-sequence 'vector 256 :initial-element #\a)))
> (declare (type (vector character 256) vec))
> vec)
>
> causes SBCL to complain
>
> The value #(#\a #\a #\a #\a #\a #\a #\a #\a #\a #\a #\a #\a ...)
> is not of type
> (VECTOR CHARACTER 256).
>
> which puzzles me. But hopefully I have given you enough to get you started.

I asked on sbcl-help mailing list, the explanation is:

On 2022/2/18 10:41, Douglas Katzman wrote:
Asking whether an object is (vector character) is asking whether that
vector can hold characters and NOTHING BUT characters.
The syntax #(obj1 obj2 obj3) creates a general vector, technically a
(vector t), which is not a vector that can hold /only/ characters.

> xord is a vector where each element is of type ASCIIcode but what
> are the possible indexes ?
>
That also confused me. I do not know how Pascal deal with it.

>> for me, the type ASCIIcode is a subrange of the integers. And xord and
>> xchr are two array with the type of ASCIIcode and char.
>
> Not clear enough.
>
>> I don't know how to translate them into Common Lisp in a elegant style.
>