dunham/newt
1
0
Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases Wiki Activity

change syntax for javascript code literals

Browse Source
This commit is contained in:
Steve Dunham
2024-11-25 21:53:23 -08:00
parent 07cbeec6cc
commit e265248b11
21 changed files with 140 additions and 287 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
aoc2023/Day2.newt
View File

@@ -25,9 +25,9 @@ max x y = case x < y of
True => y
False => x
pfunc repr : {a : U} -> a -> String := "(a,o) => ''+o"
pfunc jrepr : {a : U} -> a -> String := "(a,o) => JSON.stringify(o, null, ' ')"
pfunc toInt : String -> Int := "s => Number(s)"
pfunc repr : {a : U} -> a -> String := `(a,o) => ''+o`
pfunc jrepr : {a : U} -> a -> String := `(a,o) => JSON.stringify(o, null, ' ')`
pfunc toInt : String -> Int := `s => Number(s)`
mapM : {a b c : U} -> (a -> Either b c) -> List a -> Either b (List c)
mapM f Nil = Right Nil

40
aoc2023/Lib.newt
View File

@@ -89,22 +89,22 @@ pfunc listToArray : {a : U} -> List a -> Array a := "
return rval
}
"
pfunc alen : {a : U} -> Array a -> Int := "(a,arr) => arr.length"
pfunc aget : {a : U} -> Array a -> Int -> a := "(a, arr, ix) => arr[ix]"
pfunc aempty : {a : U} -> Unit -> Array a := "() => []"
pfunc alen : {a : U} -> Array a -> Int := `(a,arr) => arr.length`
pfunc aget : {a : U} -> Array a -> Int -> a := `(a, arr, ix) => arr[ix]`
pfunc aempty : {a : U} -> Unit -> Array a := `() => []`
pfunc getArgs : List String := "arrayToList(String, process.argv)"
pfunc getArgs : List String := `arrayToList(String, process.argv)`
-- Maybe integrate promises?
pfunc ord : Char -> Int := "(c) => c.charCodeAt(0)"
pfunc ord : Char -> Int := `(c) => c.charCodeAt(0)`
pfunc _<_ : Int -> Int -> Bool := "(x,y) => (x < y) ? True : False"
pfunc _<=_ : Int -> Int -> Bool := "(x,y) => (x <= y) ? True : False"
pfunc _+_ : Int -> Int -> Int := "(x,y) => x + y"
pfunc _-_ : Int -> Int -> Int := "(x,y) => x - y"
pfunc _*_ : Int -> Int -> Int := "(x,y) => x * y"
pfunc _/_ : Int -> Int -> Int := "(x,y) => x / y"
pfunc _<_ : Int -> Int -> Bool := `(x,y) => (x < y) ? True : False`
pfunc _<=_ : Int -> Int -> Bool := `(x,y) => (x <= y) ? True : False`
pfunc _+_ : Int -> Int -> Int := `(x,y) => x + y`
pfunc _-_ : Int -> Int -> Int := `(x,y) => x - y`
pfunc _*_ : Int -> Int -> Int := `(x,y) => x * y`
pfunc _/_ : Int -> Int -> Int := `(x,y) => x / y`
infix 6 _<_ _<=_
infixl 8 _+_ _-_
@@ -112,14 +112,14 @@ infixl 9 _*_ _/_
-- Ideally we'd have newt write the arrows for us to keep things correct
-- We'd still have difficulty with callbacks...
pfunc fs : Dummy := "require('fs')"
pfunc readFile : (fn : String) -> String := "(fn) => fs.readFileSync(fn, 'utf8')"
pfunc log : {a : U} -> a -> Dummy := "(a, obj) => console.log(obj)"
pfunc fs : Dummy := `require('fs')`
pfunc readFile : (fn : String) -> String := `(fn) => fs.readFileSync(fn, 'utf8')`
pfunc log : {a : U} -> a -> Dummy := `(a, obj) => console.log(obj)`
pfunc p_strHead : (s : String) -> Char := "(s) => s[0]"
pfunc p_strTail : (s : String) -> String := "(s) => s[0]"
pfunc p_strHead : (s : String) -> Char := `(s) => s[0]`
pfunc p_strTail : (s : String) -> String := `(s) => s[0]`
pfunc trim : String -> String := "s => s.trim()"
pfunc trim : String -> String := `s => s.trim()`
pfunc split : String -> String -> List String := "(s, by) => {
let parts = s.split(by)
let rval = Nil(String)
@@ -128,12 +128,12 @@ pfunc split : String -> String -> List String := "(s, by) => {
return rval
}"
pfunc slen : String -> Int := "s => s.length"
pfunc sindex : String -> Int -> Char := "(s,i) => s[i]"
pfunc slen : String -> Int := `s => s.length`
pfunc sindex : String -> Int -> Char := `(s,i) => s[i]`
infixl 7 _++_
pfunc _++_ : String -> String -> String := "(a,b) => a + b"
pfunc _++_ : String -> String -> String := `(a,b) => a + b`
pfunc trace : {a : U} -> String -> a -> a := "(_, lab, a) => {

6
aoc2023/Node.newt
View File

@@ -2,6 +2,6 @@ module Node
import Prelude
pfunc fs : JSObject := "require('fs')"
pfunc getArgs : List String := "arrayToList(String, process.argv)"
pfunc readFile : (fn : String) -> IO String := "(fn) => (w) => MkIORes(Unit, fs.readFileSync(fn, 'utf8'), w)"
pfunc fs : JSObject := `require('fs')`
pfunc getArgs : List String := `arrayToList(String, process.argv)`
pfunc readFile : (fn : String) -> IO String := `(fn) => (w) => MkIORes(Unit, fs.readFileSync(fn, 'utf8'), w)`

4
newt-vscode/syntaxes/newt.tmLanguage.json
View File

@@ -20,8 +20,8 @@
},
{
"name": "string.js",
"begin": ":=\\s*\"",
"end": "\"",
"begin": "`",
"end": "`",
"patterns": [
{ "include": "source.js" }
]

8
newt/JSLib.newt
View File

@@ -6,12 +6,12 @@ ptype String
infixl 4 _+_
infixl 5 _*_
pfunc _+_ : Int -> Int -> Int := "(x,y) => x + y"
pfunc _*_ : Int -> Int -> Int := "(x,y) => x * y"
pfunc _+_ : Int -> Int -> Int := `(x,y) => x + y`
pfunc _*_ : Int -> Int -> Int := `(x,y) => x * y`
ptype JVoid
-- REVIEW - maybe we only have body, use names from the pi-type and generate
-- the arrow (or inline?) ourselves
pfunc log : String -> JVoid := "x => console.log(x)"
pfunc debug : {a : U} -> String -> a -> JVoid := "(_,x,a) => console.log(x,a)"
pfunc log : String -> JVoid := `x => console.log(x)`
pfunc debug : {a : U} -> String -> a -> JVoid := `(_,x,a) => console.log(x,a)`

12
newt/Prelude.newt
View File

@@ -231,13 +231,13 @@ pfunc listToArray : {a : U} -> List a -> Array a := "
return rval
}
"
pfunc alen : {a : U} -> Array a -> Int := "(a,arr) => arr.length"
pfunc aget : {a : U} -> Array a -> Int -> a := "(a, arr, ix) => arr[ix]"
pfunc aempty : {a : U} -> Unit -> Array a := "() => []"
pfunc alen : {a : U} -> Array a -> Int := `(a,arr) => arr.length`
pfunc aget : {a : U} -> Array a -> Int -> a := `(a, arr, ix) => arr[ix]`
pfunc aempty : {a : U} -> Unit -> Array a := `() => []`
pfunc fastConcat : List String → String := "(xs) => listToArray(undefined, xs).join('')"
pfunc replicate : Nat -> Char → String := "() => abort('FIXME replicate')"
pfunc fastConcat : List String → String := `(xs) => listToArray(undefined, xs).join('')`
pfunc replicate : Nat -> Char → String := `() => abort('FIXME replicate')`
@@ -261,4 +261,4 @@ iopure a = \ w => MkIORes a w
IOMonad : Monad IO
IOMonad = MkMonad iobind iopure
pfunc putStrLn : String -> IO Unit := "(s) => (w) => console.log(s)"
pfunc putStrLn : String -> IO Unit := `(s) => (w) => console.log(s)`

2
newt/tutorial.newt
View File

@@ -11,5 +11,5 @@ ptype Int
ptype Array : U -> U
-- declare a primitive function
pfunc alength : {a : U} -> Array a -> Int := "(x) => x.length"
pfunc alength : {a : U} -> Array a -> Int := `(x) => x.length`

6
playground/samples/Day2.newt
View File

@@ -24,9 +24,9 @@ max x y = case x < y of
True => y
False => x
pfunc repr : {a : U} -> a -> String := "(a,o) => ''+o"
pfunc jrepr : {a : U} -> a -> String := "(a,o) => JSON.stringify(o, null, ' ')"
pfunc toInt : String -> Int := "s => Number(s)"
pfunc repr : {a : U} -> a -> String := `(a,o) => ''+o`
pfunc jrepr : {a : U} -> a -> String := `(a,o) => JSON.stringify(o, null, ' ')`
pfunc toInt : String -> Int := `s => Number(s)`
mapM : {a b c : U} -> (a -> Either b c) -> List a -> Either b (List c)
mapM f Nil = Right Nil

162
playground/samples/Lib.newt
View File

@@ -1,162 +0,0 @@
module Lib
-- Prelude
data Unit : U where
MkUnit : Unit
data Bool : U where
True : Bool
False : Bool
data Nat : U where
Z : Nat
S : Nat -> Nat
data Maybe : U -> U where
Just : {a : U} -> a -> Maybe a
Nothing : {a : U} -> Maybe a
data Either : U -> U -> U where
Left : {a b : U} -> a -> Either a b
Right : {a b : U} -> b -> Either a b
infixr 7 _::_
data List : U -> U where
Nil : {a : U} -> List a
_::_ : {a : U} -> a -> List a -> List a
Cons : {a : U} -> a -> List a -> List a
Cons x xs = x :: xs
-- TODO where clauses
reverse' : {A : U} -> List A -> List A -> List A
reverse' Nil acc = acc
reverse' (x :: xs) acc = reverse' xs (x :: acc)
reverse : {A : U} -> List A -> List A
reverse xs = reverse' xs Nil
length : {a : U} -> List a -> Nat
length Nil = Z
length (x :: xs) = S (length xs)
infixr 0 _,_
data Pair : U -> U -> U where
_,_ : {a b : U} -> a -> b -> Pair a b
-- Idris says it special cases to deal with unification issues
infixr 0 _$_
_$_ : {a b : U} -> (a -> b) -> a -> b
f $ a = f a
-- JS Bridge
ptype Dummy
ptype World
data IO : U -> U where
MkIO : {a : U} -> (World -> Pair World a) -> IO a
-- TODO unified Number for now
ptype Int
ptype String
ptype Char
ptype Array : U -> U
pfunc arrayToList : {a : U} -> Array a -> List a := "
(a, arr) => {
let rval = Nil(a)
for (let i = arr.length - 1; i >= 0; i--) {
rval = Cons(a, arr[i], rval)
}
return rval
}
"
pfunc listToArray : {a : U} -> List a -> Array a := "
(a, l) => {
let rval = []
while (l.tag !== 'Nil') {
rval.push(l.h1)
l = l.h2
}
return rval
}
"
pfunc alen : {a : U} -> Array a -> Int := "(a,arr) => arr.length"
pfunc aget : {a : U} -> Array a -> Int -> a := "(a, arr, ix) => arr[ix]"
pfunc aempty : {a : U} -> Unit -> Array a := "() => []"
pfunc getArgs : List String := "arrayToList(String, process.argv)"
-- Maybe integrate promises?
pfunc ord : Char -> Int := "(c) => c.charCodeAt(0)"
pfunc _<_ : Int -> Int -> Bool := "(x,y) => (x < y) ? True : False"
pfunc _<=_ : Int -> Int -> Bool := "(x,y) => (x <= y) ? True : False"
pfunc _+_ : Int -> Int -> Int := "(x,y) => x + y"
pfunc _-_ : Int -> Int -> Int := "(x,y) => x - y"
pfunc _*_ : Int -> Int -> Int := "(x,y) => x * y"
pfunc _/_ : Int -> Int -> Int := "(x,y) => x / y"
infix 6 _<_ _<=_
infixl 8 _+_ _-_
infixl 9 _*_ _/_
-- Ideally we'd have newt write the arrows for us to keep things correct
-- We'd still have difficulty with callbacks...
pfunc fs : Dummy := "require('fs')"
pfunc readFile : (fn : String) -> String := "(fn) => fs.readFileSync(fn, 'utf8')"
pfunc log : {a : U} -> a -> Dummy := "(a, obj) => console.log(obj)"
pfunc p_strHead : (s : String) -> Char := "(s) => s[0]"
pfunc p_strTail : (s : String) -> String := "(s) => s[0]"
pfunc trim : String -> String := "s => s.trim()"
pfunc split : String -> String -> List String := "(s, by) => {
let parts = s.split(by)
let rval = Nil(String)
parts.reverse()
parts.forEach(p => { rval = _$3A$3A_(List(String), p, rval) })
return rval
}"
pfunc slen : String -> Int := "s => s.length"
pfunc sindex : String -> Int -> Char := "(s,i) => s[i]"
infixl 7 _++_
pfunc _++_ : String -> String -> String := "(a,b) => a + b"
pfunc trace : {a : U} -> String -> a -> a := "(_, lab, a) => {
console.log(lab,a)
return a
}"
pfunc unpack : String -> List Char
:= "(s) => {
let acc = Nil(Char)
for (let i = s.length - 1; 0 <= i; i--) acc = _$3A$3A_(Char, s[i], acc)
return acc
}"
foldl : {A B : U} -> (B -> A -> B) -> B -> List A -> B
foldl f acc Nil = acc
foldl f acc (x :: xs) = foldl f (f acc x) xs
map : {A B : U} -> (A -> B) -> List A -> List B
map f Nil = Nil
map f (x :: xs) = f x :: map f xs
infixl 9 _∘_
_∘_ : {A B C : U} -> (B -> C) -> (A -> B) -> A -> C
(f ∘ g) x = f (g x)

66
playground/samples/Prelude.newt
View File

@@ -182,13 +182,13 @@ ptype Int
ptype Char
-- probably want to switch to Int or implement magic Nat
pfunc length : String → Nat := "(s) => {
pfunc length : String → Nat := `(s) => {
let rval = Z
for (let i = 0; i < s.length; s++) rval = S(rval)
return rval
}"
}`
pfunc sconcat : String → String → String := "(x,y) => x + y"
pfunc sconcat : String → String → String := `(x,y) => x + y`
instance Concat String where
_++_ = sconcat
@@ -196,7 +196,7 @@ data Unit : U where
MkUnit : Unit
ptype Array : U → U
pfunc listToArray : {a : U} -> List a -> Array a := "
pfunc listToArray : {a : U} -> List a -> Array a := `
(a, l) => {
let rval = []
while (l.tag !== 'Nil') {
@@ -205,52 +205,52 @@ pfunc listToArray : {a : U} -> List a -> Array a := "
}
return rval
}
"
`
pfunc alen : {a : U} -> Array a -> Int := "(a,arr) => arr.length"
pfunc aget : {a : U} -> Array a -> Int -> a := "(a, arr, ix) => arr[ix]"
pfunc aempty : {a : U} -> Unit -> Array a := "() => []"
pfunc alen : {0 a : U} -> Array a -> Int := `(a,arr) => arr.length`
pfunc aget : {0 a : U} -> Array a -> Int -> a := `(a, arr, ix) => arr[ix]`
pfunc aempty : {0 a : U} -> Unit -> Array a := `() => []`
pfunc arrayToList : {a} → Array a → List a := "(a,arr) => {
pfunc arrayToList : {0 a} → Array a → List a := `(a,arr) => {
let rval = Nil(a)
for (let i = arr.length - 1;i >= 0; i--) {
rval = _$3A$3A_(a, arr[i], rval)
}
return rval
}"
}`
-- for now I'll run this in JS
pfunc lines : String → List String := "(s) => arrayToList(s.split('\\n'))"
pfunc lines : String → List String := `(s) => arrayToList(s.split('\n'))`
pfunc p_strHead : (s : String) -> Char := "(s) => s[0]"
pfunc p_strTail : (s : String) -> String := "(s) => s[0]"
pfunc p_strHead : (s : String) -> Char := `(s) => s[0]`
pfunc p_strTail : (s : String) -> String := `(s) => s[0]`
pfunc trim : String -> String := "s => s.trim()"
pfunc split : String -> String -> List String := "(s, by) => {
pfunc trim : String -> String := `s => s.trim()`
pfunc split : String -> String -> List String := `(s, by) => {
let parts = s.split(by)
let rval = Nil(String)
parts.reverse()
parts.forEach(p => { rval = _$3A$3A_(List(String), p, rval) })
return rval
}"
}`
pfunc slen : String -> Int := "s => s.length"
pfunc sindex : String -> Int -> Char := "(s,i) => s[i]"
pfunc slen : String -> Int := `s => s.length`
pfunc sindex : String -> Int -> Char := `(s,i) => s[i]`
-- TODO represent Nat as number at runtime
pfunc natToInt : Nat -> Int := "(n) => {
pfunc natToInt : Nat -> Int := `(n) => {
let rval = 0
while (n.tag === 'S') {
n = n.h0
rval++
}
return rval
}"
}`
pfunc fastConcat : List String → String := "(xs) => listToArray(undefined, xs).join('')"
pfunc replicate : Nat -> Char → String := "(n,c) => c.repeat(natToInt(n))"
pfunc fastConcat : List String → String := `(xs) => listToArray(undefined, xs).join('')`
pfunc replicate : Nat -> Char → String := `(n,c) => c.repeat(natToInt(n))`
-- I don't want to use an empty type because it would be a proof of void
ptype World
@@ -266,12 +266,12 @@ instance Monad IO where
MkIORes a w => mab a w
pure a = \ w => MkIORes a w
pfunc putStrLn : String -> IO Unit := "(s) => (w) => {
pfunc putStrLn : String -> IO Unit := `(s) => (w) => {
console.log(s)
return MkIORes(Unit,MkUnit,w)
}"
}`
pfunc showInt : Int -> String := "(i) => String(i)"
pfunc showInt : Int -> String := `(i) => String(i)`
class Show a where
show : a → String
@@ -282,18 +282,18 @@ instance Show String where
instance Show Int where
show = showInt
pfunc ord : Char -> Int := "(c) => c.charCodeAt(0)"
pfunc ord : Char -> Int := `(c) => c.charCodeAt(0)`
infix 6 _<=_
pfunc _<=_ : Int -> Int -> Bool := "(x,y) => (x <= y) ? True : False"
pfunc _<=_ : Int -> Int -> Bool := `(x,y) => (x <= y) ? True : False`
pfunc unpack : String -> List Char
:= "(s) => {
:= `(s) => {
let acc = Nil(Char)
for (let i = s.length - 1; 0 <= i; i--) acc = _$3A$3A_(Char, s[i], acc)
return acc
}"
}`
@@ -306,10 +306,10 @@ _∘_ : {A B C : U} -> (B -> C) -> (A -> B) -> A -> C
(f ∘ g) x = f (g x)
pfunc addInt : Int → Int → Int := "(x,y) => x + y"
pfunc mulInt : Int → Int → Int := "(x,y) => x * y"
pfunc subInt : Int → Int → Int := "(x,y) => x - y"
pfunc ltInt : Int → Int → Bool := "(x,y) => x < y ? True : False"
pfunc addInt : Int → Int → Int := `(x,y) => x + y`
pfunc mulInt : Int → Int → Int := `(x,y) => x * y`
pfunc subInt : Int → Int → Int := `(x,y) => x - y`
pfunc ltInt : Int → Int → Bool := `(x,y) => x < y ? True : False`
instance Mul Int where
x * y = mulInt x y

4
playground/samples/Tour.newt
View File

@@ -118,8 +118,8 @@ isVowel _ = False
-- And primitive functions have a type and a javascript definition:
pfunc plusInt : Int -> Int -> Int := "(x,y) => x + y"
pfunc plusString : String -> String -> String := "(x,y) => x + y"
pfunc plusInt : Int -> Int -> Int := `(x,y) => x + y`
pfunc plusString : String -> String -> String := `(x,y) => x + y`
-- We can make them Plus instances:

1
playground/src/worker.ts
View File

@@ -118,7 +118,6 @@ process.stdout.write = (s) => {
};
// hack for now
const preload = [
"Lib.newt",
"Prelude.newt",
"aoc2023/day1/eg.txt",
"aoc2023/day1/eg2.txt",

66
port/Prelude.newt
View File

@@ -182,13 +182,13 @@ ptype Int
ptype Char
-- probably want to switch to Int or implement magic Nat
pfunc length : String → Nat := "(s) => {
pfunc length : String → Nat := `(s) => {
let rval = Z
for (let i = 0; i < s.length; s++) rval = S(rval)
return rval
}"
}`
pfunc sconcat : String → String → String := "(x,y) => x + y"
pfunc sconcat : String → String → String := `(x,y) => x + y`
instance Concat String where
_++_ = sconcat
@@ -196,7 +196,7 @@ data Unit : U where
MkUnit : Unit
ptype Array : U → U
pfunc listToArray : {a : U} -> List a -> Array a := "
pfunc listToArray : {a : U} -> List a -> Array a := `
(a, l) => {
let rval = []
while (l.tag !== 'Nil') {
@@ -205,52 +205,52 @@ pfunc listToArray : {a : U} -> List a -> Array a := "
}
return rval
}
"
`
pfunc alen : {0 a : U} -> Array a -> Int := "(a,arr) => arr.length"
pfunc aget : {0 a : U} -> Array a -> Int -> a := "(a, arr, ix) => arr[ix]"
pfunc aempty : {0 a : U} -> Unit -> Array a := "() => []"
pfunc alen : {0 a : U} -> Array a -> Int := `(a,arr) => arr.length`
pfunc aget : {0 a : U} -> Array a -> Int -> a := `(a, arr, ix) => arr[ix]`
pfunc aempty : {0 a : U} -> Unit -> Array a := `() => []`
pfunc arrayToList : {0 a} → Array a → List a := "(a,arr) => {
pfunc arrayToList : {0 a} → Array a → List a := `(a,arr) => {
let rval = Nil(a)
for (let i = arr.length - 1;i >= 0; i--) {
rval = _$3A$3A_(a, arr[i], rval)
}
return rval
}"
}`
-- for now I'll run this in JS
pfunc lines : String → List String := "(s) => arrayToList(s.split('\\n'))"
pfunc lines : String → List String := `(s) => arrayToList(s.split('\n'))`
pfunc p_strHead : (s : String) -> Char := "(s) => s[0]"
pfunc p_strTail : (s : String) -> String := "(s) => s[0]"
pfunc p_strHead : (s : String) -> Char := `(s) => s[0]`
pfunc p_strTail : (s : String) -> String := `(s) => s[0]`
pfunc trim : String -> String := "s => s.trim()"
pfunc split : String -> String -> List String := "(s, by) => {
pfunc trim : String -> String := `s => s.trim()`
pfunc split : String -> String -> List String := `(s, by) => {
let parts = s.split(by)
let rval = Nil(String)
parts.reverse()
parts.forEach(p => { rval = _$3A$3A_(List(String), p, rval) })
return rval
}"
}`
pfunc slen : String -> Int := "s => s.length"
pfunc sindex : String -> Int -> Char := "(s,i) => s[i]"
pfunc slen : String -> Int := `s => s.length`
pfunc sindex : String -> Int -> Char := `(s,i) => s[i]`
-- TODO represent Nat as number at runtime
pfunc natToInt : Nat -> Int := "(n) => {
pfunc natToInt : Nat -> Int := `(n) => {
let rval = 0
while (n.tag === 'S') {
n = n.h0
rval++
}
return rval
}"
}`
pfunc fastConcat : List String → String := "(xs) => listToArray(undefined, xs).join('')"
pfunc replicate : Nat -> Char → String := "(n,c) => c.repeat(natToInt(n))"
pfunc fastConcat : List String → String := `(xs) => listToArray(undefined, xs).join('')`
pfunc replicate : Nat -> Char → String := `(n,c) => c.repeat(natToInt(n))`
-- I don't want to use an empty type because it would be a proof of void
ptype World
@@ -266,12 +266,12 @@ instance Monad IO where
MkIORes a w => mab a w
pure a = \ w => MkIORes a w
pfunc putStrLn : String -> IO Unit := "(s) => (w) => {
pfunc putStrLn : String -> IO Unit := `(s) => (w) => {
console.log(s)
return MkIORes(Unit,MkUnit,w)
}"
}`
pfunc showInt : Int -> String := "(i) => String(i)"
pfunc showInt : Int -> String := `(i) => String(i)`
class Show a where
show : a → String
@@ -282,18 +282,18 @@ instance Show String where
instance Show Int where
show = showInt
pfunc ord : Char -> Int := "(c) => c.charCodeAt(0)"
pfunc ord : Char -> Int := `(c) => c.charCodeAt(0)`
infix 6 _<=_
pfunc _<=_ : Int -> Int -> Bool := "(x,y) => (x <= y) ? True : False"
pfunc _<=_ : Int -> Int -> Bool := `(x,y) => (x <= y) ? True : False`
pfunc unpack : String -> List Char
:= "(s) => {
:= `(s) => {
let acc = Nil(Char)
for (let i = s.length - 1; 0 <= i; i--) acc = _$3A$3A_(Char, s[i], acc)
return acc
}"
}`
@@ -306,10 +306,10 @@ _∘_ : {A B C : U} -> (B -> C) -> (A -> B) -> A -> C
(f ∘ g) x = f (g x)
pfunc addInt : Int → Int → Int := "(x,y) => x + y"
pfunc mulInt : Int → Int → Int := "(x,y) => x * y"
pfunc subInt : Int → Int → Int := "(x,y) => x - y"
pfunc ltInt : Int → Int → Bool := "(x,y) => x < y ? True : False"
pfunc addInt : Int → Int → Int := `(x,y) => x + y`
pfunc mulInt : Int → Int → Int := `(x,y) => x * y`
pfunc subInt : Int → Int → Int := `(x,y) => x - y`
pfunc ltInt : Int → Int → Bool := `(x,y) => x < y ? True : False`
instance Mul Int where
x * y = mulInt x y

2
src/Lib/Parser.idr
View File

@@ -399,7 +399,7 @@ parsePFunc = do
keyword ":"
ty <- typeExpr
keyword ":="
src <- cast <$> token StringKind
src <- cast <$> token JSLit
pure $ PFunc fc nm ty src
export

3
src/Lib/Token.idr
View File

@@ -13,6 +13,7 @@ data Kind
| Number
| Character
| StringKind
| JSLit
| Symbol
| Space
| Comment
@@ -40,6 +41,7 @@ Show Kind where
show EOI = "EOI"
show Pragma = "Pragma"
show StringKind = "String"
show JSLit = "JSLit"
export
Eq Kind where
Ident == Ident = True
@@ -54,6 +56,7 @@ Eq Kind where
Semi == Semi = True
RBrace == RBrace = True
StringKind == StringKind = True
JSLit == JSLit = True
_ == _ = False
export

13
src/Lib/Tokenizer.idr
View File

@@ -49,6 +49,18 @@ unquote str = case unpack str of
opMiddle = pred (\c => not (isSpace c || c == '_'))
btick = is '`'
trimJS : String -> String
trimJS str = case unpack str of
('`' :: xs) => pack $ go xs
bug => pack $ go bug
where
go : List Char -> List Char
go [] = []
go ['`'] = []
go (x :: xs) = x :: go xs
rawTokens : Tokenizer (Token Kind)
rawTokens
= match spaces (Tok Space)
@@ -68,6 +80,7 @@ rawTokens
<|> match (lineComment (exact "--")) (Tok Space)
<|> match (blockComment (exact "/-") (exact "-/")) (Tok Space)
<|> match (upper <+> many identMore) checkUKW
<|> match (btick <+> manyUntil btick any <+> btick) (Tok JSLit . trimJS)
<|> match (quo <+> manyUntil quo (esc any <|> any) <+> quo) (Tok StringKind . unquote)
-- accept almost everything, but
<|> match (some (non (space <|> singleton))) checkKW

6
tests/black/Auto.newt
View File

@@ -3,8 +3,8 @@ module Auto
ptype String
ptype Int
pfunc i2s : Int -> String := "(i) => ''+i"
pfunc _++_ : String -> String -> String := "(a,b) => a + b"
pfunc i2s : Int -> String := `(i) => ''+i`
pfunc _++_ : String -> String -> String := `(a,b) => a + b`
infixl 4 _++_
@@ -21,7 +21,7 @@ showInt : Show Int
showInt = MkShow i2s
ptype World
pfunc log : {A : U} -> A -> World := "(_, a) => console.log(a)"
pfunc log : {A : U} -> A -> World := `(_, a) => console.log(a)`
main : Int -> World
main _ = log ("answer: " ++ show 42)

4
tests/black/Auto2.newt
View File

@@ -1,10 +1,10 @@
module Auto2
ptype World
pfunc log : {A : U} -> A -> World := "(_, a) => console.log(a)"
pfunc log : {A : U} -> A -> World := `(_, a) => console.log(a)`
ptype Int
pfunc i_plus : Int -> Int -> Int := "(x,y) => x + y"
pfunc i_plus : Int -> Int -> Int := `(x,y) => x + y`
data Nat : U where
Z : Nat

6
tests/black/Oper.newt
View File

@@ -20,9 +20,9 @@ ptype JVoid
-- If we had a different quote here, we could tell vscode it's javascript.
-- or actually just switch modes inside pfunc
pfunc log : String -> JVoid := "(x) => console.log(x)"
pfunc plus : Int -> Int -> Int := "(x,y) => x + y"
pfunc _*_ : Int -> Int -> Int := "(x,y) => x * y"
pfunc log : String -> JVoid := `(x) => console.log(x)`
pfunc plus : Int -> Int -> Int := `(x,y) => x + y`
pfunc _*_ : Int -> Int -> Int := `(x,y) => x * y`
-- We now have to clean JS identifiers
_+_ : Int -> Int -> Int

2
tests/black/TestCase5.newt
View File

@@ -10,7 +10,7 @@ _+_ : {A : U} {{_ : Plus A}} -> A -> A -> A
_+_ {{MkPlus plus}} x y = plus x y
ptype Int
pfunc plusInt : Int -> Int -> Int := "(x,y) => x + y"
pfunc plusInt : Int -> Int -> Int := `(x,y) => x + y`
PlusInt : Plus Int
PlusInt = MkPlus plusInt

8
tests/black/TestPrim.newt
View File

@@ -7,7 +7,7 @@ module TestPrim
ptype String
ptype Int
pfunc strlen : String -> Int := "(x) => x.length()"
pfunc strlen : String -> Int := `(x) => x.length()`
-- why is there an eta in here?
foo : String -> Int
@@ -16,12 +16,12 @@ foo = \ x => strlen x
bar : String -> String -> Int
bar = \ x y => strlen x
pfunc append : String -> String -> String := "(a,b) => a + b"
pfunc append : String -> String -> String := `(a,b) => a + b`
blah : String
blah = append "hello" "world"
pfunc plus : Int -> Int -> Int := "(a,b) => a + b"
pfunc plus : Int -> Int -> Int := `(a,b) => a + b`
answer : Int
answer = plus 40 2
@@ -30,7 +30,7 @@ answer = plus 40 2
-- codegen test cases
-- works, but two looks like () => (eta1) => (eta0) => one(eta1, eta0)
pfunc one : Int -> Int -> Int := "(x,y) => x + y"
pfunc one : Int -> Int -> Int := `(x,y) => x + y`
two : Int -> Int -> Int
two = one