Removed file artifacts created by drracket

.gitignore

···
+*.rkt~

src/combinators.rkt~

···
-#lang plait
-(require "utilities.rkt")
-(require "types.rkt")
-
-;----- Parser 'a applicative -----;
-; The following applicative implementations for (Parser 'a) were taken
-; from the prelude implementation of haskell at:
-; https://hackage.haskell.org/package/base-4.19.1.0/docs/src/GHC.Base.html
-; Creates a parser that parses (x) regardless of input
-(define (pure [x : 'a]) : (Parser 'a)
-  (λ (input)
-    (ok (pair input x))))
-
-; Creates a parser out of two parsers that will sequence the application of the
-; first parser with the second parser. First it parses the same input with both
-; parsers then applies the function contained within the first parser to the
-; parsed result of the second parser. This is usually referred to as <*> in
-; Haskell.
-(define (seq-ap [p1 : (Parser ('a -> 'b))] [p2 : (Parser 'a)]) : (Parser 'b)
-  (λ (input)
-    (type-case (ParseResult ('a -> 'b)) (p1 input)
-      [(ok f) (do (p2 input)
-                (λ (y) (p-result (fst y) ((snd f) (snd y)))))]
-      [(err) (err)])))
-
-;----- Parser Combinators -----;
-; Creates a parser that runs the entire list of parsers through an input and
-; returns an (ok) variant if any of them succeed
-(define (or/p [ps : (Listof (Parser 'a))]) : (Parser 'a)
-  (λ (input)
-    (let ([res1 ((first ps) input)])
-    (foldr alt res1 (map (λ (p) (p input)) (rest ps))))))
-
-; Creates a parser out of two parsers that will sequence them.
-(define (seq/p [p1 : (Parser 'a)] [p2 : (Parser 'b)]) : (Parser ('a * 'b))
-  (λ (input) (do (p1 input)
-               (λ (res1) (do (p2 (fst res1))
-                           (λ (res2) (p-result (fst res2) (pair (snd res1) (snd res2)))))))))
-
-; Creates a parser that parses either (p1) or (p2)
-(define (alt/p [p1 : (Parser 'a)] [p2 : (Parser 'a)]) : (Parser 'a)
-  (λ (input) (alt (p1 input) (p2 input))))
-
-; Creates a parser that will parse the input 0 or more times. Like using "*" in
-; a RegEx.
-(define (many/p [p : (Parser 'a)]) : (Parser (Listof 'a))
-  (alt/p (many1/p p) (pure '())))
-
-; Creates a parser that parses the input 1 or more times. Like using "+" in a
-; RegEx.
-(define (many1/p [p : (Parser 'a)]) : (Parser (Listof 'a))
-  (λ (input) (type-case (ParseResult 'a) (p input)
-               [(ok first) (type-case (ParseResult (Listof 'a)) ((many/p p) (fst first))
-                             [(ok rest) (ok (pair (fst rest) (append (list (snd first)) (snd rest))))]
-                             [(err) (err)])]
-               [(err) (err)])))
-
-; Creates a parser out of two parsers that sequentially applies them. But will
-; only return the result of the first parser with the rest of the input from the
-; second parser.
-(define (left/p [l : (Parser 'a)] [r : (Parser 'b)]) : (Parser 'a)
-  (λ (input) (do (l input)
-               (λ (result1) (do (r (fst result1))
-                               (λ (result2) (p-result (fst result2) (snd result1))))))))
-
-; Creates a parser out of two parsers that sequentially applies them. But will
-; only return the result of the second parser.
-(define (right/p [l : (Parser 'a)] [r : (Parser 'b)]) : (Parser 'b)
-  (λ (input) (do (l input)
-               (λ (result1) (do (r (fst result1))
-                               (λ (result2) (ok result2)))))))

src/main.rkt~

···
-#lang plait
-
-(define (id x) x)
-
-(define-type U8
-  [num (n : Number)]
-)
-
-(define-type ImgOps
-  [interpolate (f : Number)]
-  [rotate-left]
-  [rotate-right]
-  [mirror]
-  [transpose]
-  [set (c : Color)]
-)
-
-(define-type Color
-  [hex-color (n : Number)] ;; TODO: Hex should turn a string of #FFA123 into a Number
-  [int-color (n : Number)]
-)
-
-(define-type NumOps
-  [addR (n : Number)]
-  [addL (n : Number)]
-)
-
-(define-type Expr
-  [img-op (op : ImgOps)]
-  [num-op (op : NumOps)]
-)
-
-(define (get-SetNum s) (map s-exp->number (s-exp->list s)))
-
-
-(define (parse e)
-  [cond
-    [(s-exp-match? `& e) (rotate-left)]
-    [(s-exp-match? `(Number) e) (set (get-SetNum e))]
-    [else (rotate-left)]
-  ]
-)
-
-(parse `&)
-(parse `(255))

src/types.rkt~

···
-#lang plait
-;----- Language Types -----;
-; General Expression type
-(define-type Expr
-  [operation (op : Operation)]
-  [color (c : Color)])
-
-; Operation type
-(define-type Operation
-  [add (color : Color) (e : Expr)]
-  [subtract (color : Color) (e : Expr)]
-  [multiply (color : Color) (e : Expr)]
-  [divide (color : Color) (e : Expr)]
-  [value-invert (e : Expr)]
-  [linear-invert (e : Expr)]
-  [interpolate (color : Color) (e : Expr) (percent : Number)]
-  [hue-shift (e : Expr) (shift : Number)]
-  [max (color : Color) (e : Expr)]
-  [min (color : Color) (e : Expr)])
-
-; Color type
-(define-type Color
-  [rgb-color (red : Number) (green : Number) (blue : Number)]
-  [grayscale-color (n : Number)])
-
-;----- Parser Types -----;
-(define-type (ParseResult 'a)
-  [ok (r : (String * 'a))]
-  [err])
-
-(define-type-alias (Parser 'a)
-  (String -> (ParseResult 'a)))