Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Add define-type-alias #1294

Open
wants to merge 21 commits into
base: main
Choose a base branch
from
Open

Add define-type-alias #1294

Show file tree
Hide file tree
Changes from 20 commits
Commits
Show all changes
21 commits
Select commit Hold shift + click to select a range
758cf3d
added basic define-alias toplevel form
YarinHeffes Oct 7, 2024
a125e4a
fixed alias substitution for constructors and struct-fields
YarinHeffes Oct 8, 2024
074488b
added alias tests
YarinHeffes Oct 8, 2024
688322c
improved alias error messages
YarinHeffes Oct 8, 2024
287f089
removed with-aliases-from
YarinHeffes Oct 8, 2024
77a2443
Merge branch 'coalton-lang:main' into type-alias
YarinHeffes Oct 8, 2024
e05bd8a
alias coalton-release fix
YarinHeffes Oct 8, 2024
db74f65
added parametrized type aliases
YarinHeffes Oct 16, 2024
ffbef6e
added tests for parametrized type aliases
YarinHeffes Oct 16, 2024
f252499
added describe-alias
YarinHeffes Oct 16, 2024
9dda5c2
added define-alias.txt tests
YarinHeffes Oct 16, 2024
314ff0b
add tutorial documentation for type aliases
YarinHeffes Oct 16, 2024
fde68b5
added type alias documentation guide
YarinHeffes Oct 16, 2024
c9ba647
Merge branch 'main' into type-alias
YarinHeffes Oct 16, 2024
5851da6
removed empty line
YarinHeffes Oct 17, 2024
ff0e7f7
changed :nil to nil
YarinHeffes Oct 17, 2024
9b3beda
added documentation to *pprint-aliases*
YarinHeffes Oct 17, 2024
57366b7
changed define-alias -> define-type-alias
YarinHeffes Oct 17, 2024
1aba695
Improved error message for unused type alias arguments
YarinHeffes Oct 17, 2024
e6784b8
typo fix
YarinHeffes Oct 17, 2024
8619ceb
minor fixes
YarinHeffes Nov 19, 2024
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
1 change: 1 addition & 0 deletions coalton.asd
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -256,6 +256,7 @@
(:file "recursive-let-tests")
(:file "class-tests")
(:file "struct-tests")
(:file "type-alias-tests")
(:file "list-tests")
(:file "lisparray-tests")
(:file "red-black-tests")
Expand Down
9 changes: 9 additions & 0 deletions docs/coalton-documentation-guide.md
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -33,6 +33,15 @@ that contains a filling of various sweet or savoury ingredients."
(Meat String) "A meat pie with the type of meat."))
```

### `define-type-alias`

`define-type-alias` allows for the same docstring style as `define`.

```lisp
(coalton-toplevel
(define-type-alias Index Integer
"This is a type alias for a discrete numeric type: INTEGER"))

### `define-class`

`define-class` allows for documentation both on the main form and in each method.
Expand Down
35 changes: 35 additions & 0 deletions docs/intro-to-coalton.md
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -272,6 +272,41 @@ Type definitions introduce type constructors. For example, we may construct a so

We'll see how to unpack these types using `match` later in this document.

## Type Aliases

Coalton allows the definition of parametric type aliases. Type aliases can be defined on primitive types and types created with `define-type` or `define-type-alias`.

```lisp
(coalton-toplevel
;; New type aliases are created with the DEFINE-TYPE-ALIAS operator
(define-type-alias Coordinate Integer)
(define-type-alias (Pair :a) (Tuple :a :a))
(define-type-alias Translation (Pair Coordinate -> Pair Coordinate))

(declare shift-right Translation)
(define (shift-right (Tuple x y))
(Tuple (1+ x) y))

(define shifted-coordinate (shift-right (Tuple 0 0))))
```

Outside of a Coalton expression, `describe-type-of` displays the type of a symbol, including its aliases, and returns the type. `describe-type-alias` displays the alias along with its base type and returns the base type.

```lisp
COALTON-USER> shifted-coordinate
#.(TUPLE 1 0)

COALTON-USER> (type-of 'shifted-coordinate)
(TUPLE INTEGER INTEGER)

COALTON-USER> (describe-type-of 'shifted-coordinate)
Copy link
Member

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

I think these functions and their output may need some workshopping.

Copy link
Collaborator Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Do you have any feedback as far as what is good/bad about them?

[(PAIR COORDINATE) := (TUPLE [COORDINATE := INTEGER] [COORDINATE := INTEGER])]

COALTON-USER> (describe-type-alias 'Pair)
[(PAIR :A) := (TUPLE :A :A)]
```



### Structs

Expand Down
17 changes: 16 additions & 1 deletion src/debug.lisp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -173,9 +173,24 @@
"Lookup the type of value SYMBOL in the global environment"
(tc:lookup-value-type entry:*global-environment* symbol))

(defun coalton:describe-type-of (symbol)
"Print the type of value SYMBOL along with its type aliases and return it"
(let ((tc:*pprint-type-aliases* t)
(type (tc:lookup-value-type entry:*global-environment* symbol)))
Copy link

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

It looks like these are inconsistent with how it prints aliases that are imported from other packages.

If you :use a package then this will print the alias without the package. If you don't :use a package, but do something like this:

  (declare adds (aliases2:Int -> Integer -> Integer))

then you will get an error message that does indeed print the package:

  --> <macroexpansion>:1:15
   |
 1 |  (COALTON (ADDS "hi" 2))
   |                 ^^^^ Expected type '[ALIASES2:INT := INTEGER]' but got 'STRING'

I think, since this is for debugging purposes, it would be helpful to always print the package that a type is from unless it is from the current package or coalton-prelude. Maybe any of the library functions.

Here is another example. In this error message, we don't :use the package. In the error message, the alias is printed with one : but the type it refers to (from the same package) is printed with two ::'s:

"aliases2"

(in-package :cl-user)
(defpackage :aliases2
  (:use
   #:coalton
   #:coalton-prelude)
  (:export
   :Int
   :Ham
   :Swiss
   :Cheese))
(in-package :aliases2)

(coalton-toplevel
  (define-type MoldyMilk Ham Swiss)

  (define-type-alias Cheese MoldyMilk))

(coalton-toplevel
  (define-type-alias Int Integer))

aliases (main package)

(in-package :cl-user)
(defpackage :aliases
  (:use
   #:coalton
   #:coalton-prelude))
   ;; #:aliases2)) <---- not using the other package
(in-package :aliases)

(coalton-toplevel
  (declare value-of-cheese (aliases2:Cheese -> Integer))
  (define (value-of-cheese chs)
    (match chs
      ((aliases2:Ham) 10)
      ((aliases2:Swiss) 20))))

(coalton (value-of-cheese "not cheese"))
error: Type mismatch
  --> <macroexpansion>:1:26
   |
 1 |  (COALTON (VALUE-OF-CHEESE "not cheese"))
   |                            ^^^^^^^^^^^^ Expected type '[ALIASES2:CHEESE := ALIASES2::MOLDYMILK]' but got 'STRING'

Copy link
Collaborator Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

I will take a closer look at the behavior of describe-type-of. But regarding your examples, I believe those are all expected behaviors.

First, the use of : versus :: depends on whether is a symbol is exported. If a package p exports a symbol s, and you do not want to :use package p, then you can use the symbol with p:s. If p does not export s, then you can still use it with p::s. In your example, aliases2 exports cheese but not moldymilk.

Second, when package p :uses package q, the symbols from q receive the same treatment locally, in p, as any other symbol defined in p, so my personal opinion is that it is not inconsistent for those types aliases to be printed without the q: prefix.

Copy link

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

That makes sense 👍

(format t "~S~%" type)
type))

(defun coalton:describe-type-alias (symbol)
"Lookup the type represented by the type alias SYMBOL in the global environment"
(let ((tc:*pprint-type-aliases* t)
(type (tc:type-alias-entry-type (tc:lookup-type-alias entry:*global-environment* symbol))))
(tc:with-pprint-variable-context ()
(format t "~S~%" type))
type))

(defun coalton:kind-of (symbol)
"Lookup the kind of type SYMBOL in the global environment"
(tc:kind-of (coalton-impl/typechecker::type-entry-type (tc:lookup-type entry:*global-environment* symbol))))
(tc:kind-of (tc:type-entry-type (tc:lookup-type entry:*global-environment* symbol))))

(defun coalton:lookup-code (name)
"Lookup the compiled code of a given definition"
Expand Down
1 change: 1 addition & 0 deletions src/entry.lisp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -37,6 +37,7 @@
(multiple-value-bind (type-definitions instances env)
(tc:toplevel-define-type (parser:program-types program)
(parser:program-structs program)
(parser:program-type-aliases program)
env)

(let ((all-instances (append instances (parser:program-instances program))))
Expand Down
3 changes: 3 additions & 0 deletions src/faux-macros.lisp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -33,6 +33,9 @@
(define-coalton-editor-macro coalton:define-type (name &body definition)
"Create a new algebraic data type named NAME. (Coalton top-level operator.)")

(define-coalton-editor-macro coalton:define-type-alias (name &body definition)
"Create a new type alias named NAME. (Coalton top-level operator.)")

(define-coalton-editor-macro coalton:define-struct (name &body definition)
"Create a new sruct named NAME. (Coalton top-level operator.)")

Expand Down
3 changes: 3 additions & 0 deletions src/package.lisp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -23,6 +23,7 @@
#:declare
#:define
#:define-type
#:define-type-alias
#:define-struct
#:define-class
#:define-instance
Expand Down Expand Up @@ -108,6 +109,8 @@
#:lookup-class
#:lookup-fundeps
#:type-of
#:describe-type-of
#:describe-type-alias
#:kind-of)

(:intern
Expand Down
8 changes: 8 additions & 0 deletions src/parser/collect.lisp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -60,6 +60,10 @@
(declare (values tycon-list))
(mapcan #'collect-referenced-types-generic% (toplevel-define-type-ctors type)))

(:method ((alias toplevel-define-type-alias))
(declare (values (tycon-list)))
(collect-referenced-types-generic% (toplevel-define-type-alias-type alias)))

(:method ((field struct-field))
(declare (values tycon-list &optional))
(collect-referenced-types-generic% (struct-field-type field)))
Expand Down Expand Up @@ -106,6 +110,10 @@
(declare (values tyvar-list))
(mapcan #'collect-type-variables-generic% (toplevel-define-type-ctors type)))

(:method ((alias toplevel-define-type-alias))
(declare (values tyvar-list))
(collect-type-variables-generic% (toplevel-define-type-alias-type alias)))

(:method ((method method-definition))
(declare (values tyvar-list &optional))
(collect-type-variables-generic% (method-definition-type method)))
Expand Down
19 changes: 19 additions & 0 deletions src/parser/renamer.lisp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -516,6 +516,7 @@
(make-program
:package (program-package program)
:types (rename-type-variables (program-types program))
:type-aliases (rename-type-variables (program-type-aliases program))
:structs (rename-type-variables (program-structs program))
:declares (program-declares program)
:defines (rename-variables-generic% (program-defines program) ctx)
Expand Down Expand Up @@ -627,6 +628,24 @@
:repr (toplevel-define-type-repr toplevel)
:head-location (toplevel-define-type-head-location toplevel))))

(:method ((toplevel toplevel-define-type-alias) ctx)
(declare (type algo:immutable-map ctx)
(values toplevel-define-type-alias))

(let* ((tvars (mapcar #'keyword-src-name (toplevel-define-type-alias-vars toplevel)))

(new-bindings (make-local-vars tvars :package util:+keyword-package+))

(new-ctx (algo:immutable-map-set-multiple ctx new-bindings)))

(make-toplevel-define-type-alias
:name (toplevel-define-type-alias-name toplevel)
:vars (rename-type-variables-generic% (toplevel-define-type-alias-vars toplevel) new-ctx)
:docstring (source:docstring toplevel)
:type (rename-type-variables-generic% (toplevel-define-type-alias-type toplevel) new-ctx)
:location (source:location toplevel)
:head-location (toplevel-define-type-alias-head-location toplevel))))

(:method ((field struct-field) ctx)
(declare (type algo:immutable-map ctx)
(values struct-field))
Expand Down
144 changes: 135 additions & 9 deletions src/parser/toplevel.lisp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -36,6 +36,13 @@
#:toplevel-define-type-repr ; ACCESSOR
#:toplevel-define-type-head-location ; ACCESSOR
#:toplevel-define-type-list ; TYPE
#:toplevel-define-type-alias ; STRUCT
#:make-toplevel-define-type-alias ; CONSTRUCTOR
#:toplevel-define-type-alias-name ; ACCESSOR
#:toplevel-define-type-alias-vars ; ACCESSOR
#:toplevel-define-type-alias-type ; ACCESSOR
#:toplevel-define-type-alias-head-location ; ACCESSOR
#:toplevel-define-type-alias-list ; TYPE
#:struct-field ; STRUCT
#:make-struct-field ; CONSTRUCTOR
#:struct-field-name ; ACCESSOR
Expand Down Expand Up @@ -112,6 +119,7 @@
#:program-package ; ACCESSOR
#:program-lisp-forms ; ACCESSOR
#:program-types ; ACCESSOR
#:program-type-aliases ; ACCESSOR
#:program-structs ; ACCESSOR
#:program-declares ; ACCESSOR
#:program-defines ; ACCESSOR
Expand Down Expand Up @@ -169,6 +177,9 @@
;;;; toplevel-define-type := "(" "define-type" identifier docstring? constructor* ")"
;;;; | "(" "define-type" "(" identifier keyword+ ")" docstring? constructor* ")"
;;;;
;;;; toplevel-define-type-alias := "(" "define-type-alias" identifier ty docstring? ")"
;;;; | "(" "define-type-alias" "(" identifier keyword+ ")" ty docstring? ")"
;;;;
;;;; struct-field := "(" identifier docstring? type ")"
;;;;
;;;; toplevel-define-struct := "(" "define-struct" identifier docstring? struct-field* ")"
Expand Down Expand Up @@ -265,6 +276,22 @@
(deftype toplevel-define-type-list ()
'(satisfies toplevel-define-type-list-p))

(defstruct (toplevel-define-type-alias
(:include toplevel-definition)
(:copier nil))
(name (util:required 'name) :type identifier-src :read-only t)
(vars (util:required 'vars) :type keyword-src-list :read-only t)
(type (util:required 'type) :type ty :read-only t)
(head-location (util:required 'head-location) :type source:location :read-only t))

(eval-when (:load-toplevel :compile-toplevel :execute)
(defun toplevel-define-type-alias-list-p (x)
(and (alexandria:proper-list-p x)
(every #'toplevel-define-type-alias-p x))))

(deftype toplevel-define-type-alias-list ()
'(satisfies toplevel-define-type-alias-list-p))

(defstruct (struct-field
(:include toplevel-definition)
(:copier nil))
Expand Down Expand Up @@ -464,15 +491,16 @@
(export nil :type list))

(defstruct program
(package nil :type (or null toplevel-package) :read-only t)
(types nil :type toplevel-define-type-list :read-only nil)
(structs nil :type toplevel-define-struct-list :read-only nil)
(declares nil :type toplevel-declare-list :read-only nil)
(defines nil :type toplevel-define-list :read-only nil)
(classes nil :type toplevel-define-class-list :read-only nil)
(instances nil :type toplevel-define-instance-list :read-only nil)
(lisp-forms nil :type toplevel-lisp-form-list :read-only nil)
(specializations nil :type toplevel-specialize-list :read-only nil))
(package nil :type (or null toplevel-package) :read-only t)
(types nil :type toplevel-define-type-list :read-only nil)
(type-aliases nil :type toplevel-define-type-alias-list :read-only nil)
(structs nil :type toplevel-define-struct-list :read-only nil)
(declares nil :type toplevel-declare-list :read-only nil)
(defines nil :type toplevel-define-list :read-only nil)
(classes nil :type toplevel-define-class-list :read-only nil)
(instances nil :type toplevel-define-instance-list :read-only nil)
(lisp-forms nil :type toplevel-lisp-form-list :read-only nil)
(specializations nil :type toplevel-specialize-list :read-only nil))

(defun read-program (stream source &optional mode)
"Read a PROGRAM from SOURCE (an instance of source-error:source).
Expand Down Expand Up @@ -520,6 +548,7 @@ If MODE is :macro, a package form is forbidden, and an explicit check is made fo
"attribute must be attached to another form")))

(setf (program-types program) (nreverse (program-types program)))
(setf (program-type-aliases program) (nreverse (program-type-aliases program)))
(setf (program-structs program) (nreverse (program-structs program)))
(setf (program-declares program) (nreverse (program-declares program)))
(setf (program-defines program) (nreverse (program-defines program)))
Expand Down Expand Up @@ -858,6 +887,12 @@ If the parsed form is an attribute (e.g., repr or monomorphize), add it to to AT
(push type (program-types program))
t))

((coalton:define-type-alias)
(forbid-attributes attributes form source)
(let ((alias (parse-define-type-alias form source)))
(push alias (program-type-aliases program))
t))

((coalton:define-struct)
(let* ((struct (parse-define-struct form source))
(repr (consume-repr attributes struct "when parsing define-struct")))
Expand Down Expand Up @@ -1107,6 +1142,97 @@ consume all attributes")))
:location (form-location source form)
:head-location (form-location source (cst:second form)))))

(defun parse-define-type-alias (form source)
(declare (type cst:cst form)
(values toplevel-define-type-alias))

(assert (cst:consp form))

(let (docstring
name
variables)

;; (define-type-alias)
(unless (cst:consp (cst:rest form))
(parse-error "Malformed type alias definition"
(note source form "expected body")))

(cond
;; (define-type-alias _ ...)
((cst:atom (cst:second form))
;; (define-type-alias 0.5 ...)
(unless (identifierp (cst:raw (cst:second form)))
(parse-error "Malformed type alias definition"
(note source (cst:second form) "expected symbol")))

;; (define-type-alias name ...)
(setf name (make-identifier-src :name (cst:raw (cst:second form))
:location (form-location source form))))

;; (define-type-alias (_ ...) ...)
(t
;; (define-type-alias((name) ...) ...)
(unless (cst:atom (cst:first (cst:second form)))
(parse-error "Malformed type alias definition"
(note source (cst:first (cst:second form))
"expected symbol")
(help source (cst:second form)
(lambda (existing)
(subseq existing 1 (1- (length existing))))
"remove parentheses")))

;; (define-type-alias (0.5 ...) ...)
(unless (identifierp (cst:raw (cst:first (cst:second form))))
(parse-error "Malformed type alias definition"
(note source (cst:first (cst:second form))
"expected symbol")))

;; (define-type-alias (name ...) ...)
(setf name (make-identifier-src :name (cst:raw (cst:first (cst:second form)))
:location (form-location source
(cst:first (cst:second form)))))

;; (define-type-alias (name) ...)
(when (cst:atom (cst:rest (cst:second form)))
(parse-error "Malformed type alias definition"
(note source (cst:second form)
"nullary type aliases should not have parentheses")
(help source (cst:second form)
(lambda (existing)
(subseq existing 1 (1- (length existing))))
"remove unnecessary parentheses")))

;; (define-type-alias (name type-variables+) ...)
(loop :for vars := (cst:rest (cst:second form)) :then (cst:rest vars)
Copy link
Member

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

check that the tyvars are unique

Copy link
Collaborator Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

This takes place during the type checking phase, similar to define-struct and define-type

Copy link

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

(https://github.com/coalton-lang/coalton/pull/1294/files#diff-ae01ad44c79e0347430c5826a5c355990288337845de14a0bac46c3d601b25efL79)

:while (cst:consp vars)
:do (push (parse-type-variable (cst:first vars) source) variables))))

;; (define-type-alias name)
(unless (cst:consp (cst:rest (cst:rest form)))
(parse-error "Malformed type alias definition"
(note source form "expected type")))

;; (define-type-alias name type docstring)
(when (and (cst:consp (cst:nthrest 3 form))
(cst:atom (cst:fourth form))
(stringp (cst:raw (cst:fourth form))))
(setf docstring (cst:raw (cst:fourth form))))

;; (define-type-alias name type docstring ...)
(when (and docstring
(cst:consp (cst:nthrest 4 form)))
(parse-error "Malformed type alias definition"
(note source (cst:fifth form)
"unexpected trailing form")))

(make-toplevel-define-type-alias
:name name
:vars (reverse variables)
:type (parse-type (cst:third form) source)
:docstring docstring
:location (form-location source form)
:head-location (form-location source (cst:second form)))))

(defun parse-define-struct (form source)
(declare (type cst:cst form))

Expand Down
Loading
Loading